JavaScript passer portée à une autre fonction

La seule façon de vraiment obtenir l'accès à la fonction a's portée privée est de déclarer b à l'intérieur de a de sorte qu'il forme une fermeture qui permet l'accès implicite à a's variables.

Voici quelques options pour vous.

Accès Direct

1. Déclarer b à l'intérieur de a.

   function a() {
      var x = 5,
         obj = {};
      function b(){
         //access x or obj...
      }
      b();
   }
   
   a();

2. Si vous ne voulez pas b à l'intérieur de a, alors vous pourriez avoir à l'intérieur d'un récipient plus grand champ d'application:

   function container() {
      var x, obj;
      function a(){
         x = 5;
         obj = {..};
         b();
      }
      function b(){
         //access x or obj...
      }
   }
   
   container.a();

Ce sont les seuls moyens que vous allez être en mesure d'utiliser a's variables directement dans b sans code supplémentaire pour déplacer les choses. Si vous êtes satisfait avec un peu de "l'aide" et/ou d'indirection, voici quelques autres idées.

Accès Indirect

1. Vous pouvez simplement passer les variables en paramètres, mais ne pas avoir l'accès en écriture à l'exception des propriétés des objets:

   function a() {
      var x = 5,
         obj = {};
      b(x, obj);
   }
   
   function b(x, obj){
      //access x or obj...
      //changing x here won't change x in a, but you can modify properties of obj
   }
   
   a();

   Comme une variation sur ce que vous pourriez obtenir l'accès en écriture par un passage à la mise à jour des valeurs de retour de a comme suit:

   //in a:
   var ret = b(x, obj);
   x = ret.x;
   obj = ret.obj;
   
   //in b:
   return {x : x, obj : obj};

2. Vous pouvez passer b un objet avec des getters et setters qui peuvent accéder à a's variables privées:

   function a(){
      var x = 5,
         obj = {..},
         translator = {
            getX : function() {return x;},
            setX : function(value) {x = value;},
            getObj : function() {return obj;},
            setObj : function(value) {obj = value;}
         };
      b(translator);
   }
   
   function b(t){
      var x = t.getX(),
         obj = t.getObj();
   
      //use x or obj...
      t.setX(x);
      t.setObj(obj);
   
      //or you can just directly modify obj's properties:
      obj.key = value;
   }
   
   a();

   Les getters et setters pourrait être publique, affecté à la this objet de a, mais de cette façon, ils ne sont accessibles que si explicitement à partir de l'intérieur a.

3. Et vous pourriez mettre vos variables dans un objet et de passer de l'objet autour de:

   function a(){
      var v = {
         x : 5,
         obj : {}
      };
      b(v);
   }
   
   function b(v){
      //access v.x or v.obj...
      //or set new local x and obj variables to these and use them.
   }
   
   a();

   Comme une variation, vous pouvez construire l'objet à l'heure de l'appel à la place:

   function a(){
      var x = 5,
         obj = {};
      b({x : x, obj: obj});
   }
   
   function b(v){
      //access v.x or v.obj...
      //or set new local x and obj variables to these and use them.
   }
   
   a();

Pas.

Vous êtes accédant à la portée locale de l'objet. Le [[Context]].

Vous ne peut pas publiquement accéder.

Maintenant, puisque c'est node.js vous devriez être en mesure d'écrire un C++ plugin qui vous donne accès à la [[Context]] objet. Je très recommander à l'encontre de ce qu'il apporte de propriété des extensions au langage JavaScript.

Comme d'autres l'ont dit, vous ne pouvez pas passer portée comme ça. Vous pouvez cependant la portée des variables correctement à l'aide de l'autonomie de l'exécution des fonctions anonymes (ou immédiatement exécuter si vous êtes pédant):

(function(){
    var x = 5;
    var obj = {x:x};
    module.a = function(){
        module.b();
    };
    module.b = function(){
        alert(obj.x);    
    };
}());

a();

Vous ne pouvez pas passer la portée"... pas que je sache.

Vous pouvez passer de l'objet que la fonction fait référence à l'aide de apply ou call et de l'envoyer à l'objet courant (this) comme premier paramètre au lieu de simplement l'appel de la fonction:

function b(){
    alert(this.x);
}
function a(){
    this.x = 2;
    b.call(this);
}

La seule façon pour une fonction permettant d'accéder à une certaine portée doit être déclaré dans le champ d'application.

Genre a difficile.

Cela mènerait à quelque chose comme :

function a(){
    var x = 1;
    function b(){
        alert(x);
    }
}

Mais qui sorte de défaite la fin.

function a(){
   var x = 5;
   var obj = {..};
   var b = function()
   {
        document.println(x);
   }
   b.call();
}

Avez-vous essayé quelque chose comme ceci:

function a(){
   var x = 5;
   var obj = {..};
   b(this);
}
function b(fnA){
   //access x or obj....
   fnA.obj = 6;
}

Si vous pouvez supporter la fonction B comme une méthode de la fonction de A, puis le faire:

function a(){
   var x = 5;
   var obj = {..};
   b(this);

   this.b = function (){
      //"this" keyword is still === function a
   }
}