Javascript 闭包

Posted 农民伯伯-Coding

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Javascript 闭包相关的知识,希望对你有一定的参考价值。

闭包

    闭包是含有自由变量的函数。自由变量指的是不是函数局部变量,且不是函数参数的变量。比如

var a = 10;
function test(m){
     alert(a + m);
}
test(10);

 

    上面代码中,a就是函数test的自由变量,test也就是一个闭包。至于test能够访问到a,是因为在函数test被定义的时候,它的[[scope]]属性中就包含了全局变量a;之后在test被执行的时候,它的Execution context的Scope Chain中就可以找到a.

闭包原理

    在javascript中,使用静态作用域。即函数的作用域在函数定义的时候被确定,函数运行时它内部用到的变量,就从该静态作用域中查找。

var x = 10;
function foo() {
  alert(x);
}
/*
此时,foo的 [[scope]]  = 
{
x: 10,
this:window
...
}
*/
(function (funArg) {
  var x = 20;
  // 变量"x"在(lexical)上下文中静态保存的,在该函数创建的时候就保存了
  funArg(); // 10, 而不是20
})(foo);
/*
匿名函数的[[scope]] 为 {x:20, this:window, ....}

匿名函数执行的时候,其Execution context的scope chain为 
AO(匿名函数) + 匿名函数的[[scope]] = AO(匿名函数) -- > VO(global),即为
{x:20, funArg: reference of function} --> {x:10, this:window, ....}

当foo在匿名函数内部被执行的时候,它的Execution context的scope chain为 
AO(foo) + foo.[[scope]]
AO(foo)  -- > VO(global),即 {} -->{x:10, this:window}

*/

 

    在一个函数被创建的时候,函数的内部属性[[scope]]中就保存了其父级上下文的所有参数信息。在上面的例子中,函数foo 在创建时,保存了其父级上下文的参数 x =10, 在foo作为参数传递给 匿名函数,并在匿名函数中被调用时,尽管匿名函数内部有变量x,但是函数 foo被调用时,它的作用域链是使用AO(foo) + foo.[[scope]]构成,索引x的时候,返回10(见上面注释).

    如果上面的程序中,没有在在全局位置处声明x,即:

function foo() {
  alert(x);
}

(function (funArg) {
  var x = 20;
  // 变量"x"在(lexical)上下文中静态保存的,在该函数创建的时候就保存了
  funArg(); // 10, 而不是20
})(foo);
/*
匿名函数的[[scope]] 为 {x:20, this:window, ....}

匿名函数执行的时候,其Execution context的scope chain为 
AO(匿名函数) + 匿名函数的[[scope]] = AO(匿名函数) -- > VO(global),即为
{x:20, funArg: reference of function} --> {this:window, ....}

当foo在匿名函数内部被执行的时候,它的Execution context的scope chain为 
AO(foo) + foo.[[scope]]
AO(foo)  -- > VO(global),即 {} -->{this:window}
*/

 

则尽管在匿名函数中声明了变量x,但是执行foo的时候其作用域链不包含匿名函数的AO, 会报错x is undefined.

    因此,闭包就是包含了父上下文中自由变量的函数,它能够引用定义在它外部的自由变量,是因为js的scope chain和VO/AO和[[scope]]的机制(见Javascript 运行上下文和作用域链);且它的[[scope]]在它被定义的时候就确定了,而不是在运行的时候确定。

所有对象都引用同一个[[scope]]

    在ECMAScript中,同一个父上下文中创建的闭包是共用同一个[[scope]]属性,即某个闭包对其中[[scope]]的变量做修改会影响到其他闭包对其变量的读取。
如:

var firstClosure;
var secondClosure;
function foo() {
  var x = 1;
  firstClosure = function () { return ++x; };
  secondClosure = function () { return --x; };
  x = 2; // 影响 AO["x"], 在2个闭包公有的[[Scope]]中
  alert(firstClosure()); // 3, 通过第一个闭包的[[Scope]]
}
foo();
alert(firstClosure()); // 4
alert(secondClosure()); // 3

以及下面的:
var data = [];
for (var k = 0; k < 3; k++) {
  data[k] = function () {
    alert(k);
  };
}
data[0](); // 3, 而不是0
data[1](); // 3, 而不是1
data[2](); // 3, 而不是2
data[k] 的 [[scope]] 都是 {k: xx, ...}, 这是共用的,当k变更的时候会影响到data[]的[[scope]].

 

 

    那么,如何修改上面的代码使得data[k] = k呢?一种方法是封装一层函数,增加一层作用域,在该层作用域中保存k的值。

var data = [];

for (var k = 0; k < 3; k++) {
  data[k] = (function _helper(x) {
    return function () {
      alert(x);
    };
  })(k); // 传入"k"值
}

// 现在结果是正确的了
data[0](); // 0
data[1](); // 1
data[2](); // 2

data[0].[[Scope]] === [
  ... // 其它变量对象
  父级上下文中的活动对象AO: {data: [...], k: 3},
  _helper上下文中的活动对象AO: {x: 0}
];

data[1].[[Scope]] === [
  ... // 其它变量对象
  父级上下文中的活动对象AO: {data: [...], k: 3},
  _helper上下文中的活动对象AO: {x: 1}
];

data[2].[[Scope]] === [
  ... // 其它变量对象
  父级上下文中的活动对象AO: {data: [...], k: 3},
  _helper上下文中的活动对象AO: {x: 2}
];

 

 

参考
深入理解JavaScript系列(16):闭包(Closures)

以上是关于Javascript 闭包的主要内容,如果未能解决你的问题,请参考以下文章

Spark闭包与序列化

JavaScript ---- 闭包(什么是闭包,为什么使用闭包,闭包的作用)

JavaScript 闭包(随笔)

javascript中的闭包

Javascript中的闭包

Javascript中的闭包(转载)