JavaScript 将作用域传递给另一个函数

Question

是否有可能以某种方式将函数的作用域传递给另一个函数？

例如，

function a(){
   var x = 5;
   var obj = {..};
   b(<my-scope>);
}

function b(){
   //access x or obj....
}

我宁愿直接访问变量，即不使用this.a或this.obj之类的任何东西，而直接使用x或obj。

Answer 1

你真的只能用 eval 来做到这一点。下面将给出函数b函数a的作用域

  function a(){
     var x = 5;
     var obj = {x};
     eval('('+b.toString()+'())');
  }
  
  function b(){
     //access x or obj....
     console.log(x);
  }
  
  a();  //5

Answer 2

真正访问函数a 的私有作用域的唯一方法是在a 内声明b，这样它就形成了一个允许隐式访问a 变量的闭包。

这里有一些选项供您选择。

直接访问

1. 在a 内声明b。

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

2. 如果您不想将b 放在a 中，那么您可以将它们都放在更大的容器范围内：

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

这些是您可以直接在b 中使用a 的变量的唯一方法，而无需一些额外的代码来移动。如果您满足于一点“帮助”和/或间接性，这里还有一些想法。

间接访问

1. 您可以只将变量作为参数传递，但除了对象的属性外没有写入权限：

   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();
   

   作为一种变体，您可以通过将更新后的值传回a 来获得写入权限，如下所示：

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

2. 你可以传递b一个带有getter和setter的对象，可以访问a的私有变量：

   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();
   

   getter 和 setter 可以是公共的，分配给 a 的 this 对象，但这样它们只有在 a 中明确给出时才能访问。

3. 您可以将变量放在一个对象中并传递该对象：

   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();
   

   作为一种变体，您可以在调用时构造对象：

   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();
   

Answer 3

你不能“通过范围”...不是我所知道的。
您可以使用apply 或call 传递函数所引用的对象，并将当前对象（this）作为第一个参数发送，而不仅仅是调用函数：

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

函数访问特定范围的唯一方法是在该范围内声明。
有点棘手。
这会导致类似：

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

但这会破坏目的。

Answer 4

我认为您可以做的最简单的事情是将变量从一个范围传递到该范围之外的函数。如果您通过引用传递（如对象），b 有 '访问'它（参见下面的 obj.someprop）：

function a(){
   var x = 5;
   var obj = {someprop : 1};
   b(x, obj);
   alert(x); => 5
   alert(obj.someprop); //=> 'otherval'
}
function b(aa,obj){
   x += 1; //won't affect x in function a, because x is passed by value
   obj.someprop = 'otherval'; //change obj in function a, is passed by reference
}

Answer 5

你有没有尝试过这样的事情：

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

如果您可以将函数 B 视为方法函数 A，请执行以下操作：

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

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

Answer 6

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

Answer 7

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

}

Answer 8

正如其他人所说，您不能像那样传递范围。但是，您可以使用自执行匿名函数正确地确定变量的范围（或者如果您是迂腐的，则立即执行）：

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

a();

Answer 9

作用域是由函数创建的，作用域与函数保持一致，因此最接近您要求的是将函数从a() 传递到b()，并且该函数将继续具有从a() 访问作用域变量。

function a(){
   var x = 5;
   var obj = {..};
   b(function() { /* this can access var x and var obj */ });
}
function b( fn ){

    fn(); // the function passed still has access to the variables from a()

}

虽然b() 无法直接访问函数所传递的变量，但如果传递的函数返回对象。

function a(){
   var x = 5;
   var obj = {..};
   b(function() { x++; return obj; });
}
function b( fn ){

    var obj = fn();
    obj.some_prop = 'some value'; // This new property will be updated in the
                                  //    same obj referenced in a()

}

Answer 10

如何使用bind

function funcA(param) {     
    var bscoped = funcB.bind(this);     
    bscoped(param1,param2...)
}

Answer 11

没有。

您正在访问本地范围对象。 [[Context]]。

您不能公开访问它。

现在既然是 node.js，您应该能够编写一个 C++ 插件，让您可以访问 [[Context]] 对象。我强烈建议不要这样做，因为它为 JavaScript 语言带来了专有扩展。