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

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

这里有一些供您选择。

直接访问

1. 在a内部声明b。

   函数 a() {
      变量 x = 5,
         对象 = {};
      函数 b(){
         // 访问 x 或 obj...
      }
      b();
   }
   
   一个（）;
   

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

   函数容器() {
      var x, obj;
      函数 a(){
         x = 5；
         对象 = {..};
         b();
      }
      函数 b(){
         // 访问 x 或 obj...
      }
   }
   
   容器.a();
   

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

间接访问

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

   函数 a() {
      变量 x = 5,
         对象 = {};
      b(x, 对象);
   }
   
   函数 b(x, obj){
      // 访问 x 或 obj...
      // 这里改变x不会改变a中的x，但你可以修改obj的属性
   }
   
   一个（）;
   

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

   // 在：
   var ret = b(x, obj);
   x = ret.x;
   obj = ret.obj;
   
   // 在 b 中：
   返回 {x: x, obj: obj};
   

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

   函数 a(){
      变量 x = 5,
         对象 = {..},
         译者={
            getX : function() {返回 x;},
            setX : 函数(值) {x = 值;},
            getObj : function() {返回 obj;},
            setObj : 函数(值) {obj = 值;}
         };
      b（译者）；
   }
   
   函数 b(t){
      var x = t.getX(),
         obj = t.getObj();
   
      // 使用 x 或 obj...
      t.setX(x);
      t.setObj(obj);
   
      // 或者你可以直接修改 obj 的属性：
      obj.key = 值；
   }
   
   一个（）;
   

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

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

   函数 a(){
      变量 v = {
         x：5，
         对象：{}
      };
      b(v)；
   }
   
   函数 b(v){
      // 访问 vx 或 v.obj...
      // 或为它们设置新的局部 x 和 obj 变量并使用它们。
   }
   
   一个（）;
   

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

   函数 a(){
      变量 x = 5,
         对象 = {};
      b({x : x, obj: obj});
   }
   
   函数 b(v){
      // 访问 vx 或 v.obj...
      // 或者为它们设置新的局部 x 和 obj 变量并使用它们。
   }
   
   一个（）;
   

Answer 2

作用域是由函数创建的，作用域与函数保持一致，因此最接近您要求的是将函数从 a() 传递到 b()< /code>，并且该函数将继续访问 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() 无法直接访问函数传递的变量，但如果函数传递返回，则可以访问传递引用的数据类型（例如对象） /em> 那个对象。

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 3

使用bind怎么样

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

Answer 4

不。

您正在访问本地范围对象。 [[上下文]]。

您无法公开访问它。

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

Answer 5

你不能“通过范围”……据我所知，情况并非如此。
您可以使用 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 6

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

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

a();

Answer 7

我认为您可以做的最简单的事情就是将变量从一个作用域传递到该作用域之外的函数。如果您通过引用传递（如对象），则 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 8

你实际上只能通过 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 9

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

}

Answer 10

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

Answer 11

您是否尝试过这样的事情：

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
   }
}