JS进阶之---作用域，作用域链，闭包

一、作用域：

　　在JavaScript中，我们可以将作用域定义为一套规则,这套规则用来管理引擎如何在当前作用域以及嵌套的子作用域中根据标识符名称进行变量查找。这里的标识符，指的是变量名或者函数名。

　　JavaScript中只有全局作用域与函数作用域(因为eval我们平时开发中几乎不会用到它，这里不讨论)。

　　作用域与执行上下文是完全不同的两个概念。

　　JavaScript代码的整个执行过程，分为两个阶段，代码编译阶段与代码执行阶段。编译阶段由编译器完成，将代码翻译成可执行代码，这个阶段作用域规则会确定。执行阶段由引擎完成，主要任务是执行可执行代码，执行上下文在这个阶段创建。

　　作用域在编译阶段确定规则，可是为什么作用域链却在执行阶段的创建过程确定？之所以有这个疑问，是因为大家对作用域和作用域链有一个误解。我们上面说了，作用域是一套规则，那么作用域链是什么呢？是这套规则的具体实现。

二、作用域链

　　作用域链，是由当前环境与上层环境的一系列变量对象组成，它保证了当前执行环境对符合访问权限的变量和函数的有序访问。

　　简单说就是函数可以访问的一系列的作用域中的变量对象。

var a = 20;

function test() {

    var b = a + 10;

    function innerTest() {

        var c = 10;

        return b + c;

    }

    return innerTest();

}

test();

　　在上面的例子中，全局，函数test，函数innerTest的执行上下文先后创建。我们设定他们的变量对象分别为VO(global)，VO(test), VO(innerTest)。而innerTest的作用域链，则同时包含了这三个变量对象，所以innerTest的执行上下文可如下表示。　

innerTestEC = {

    VO: {...},  // 变量对象

    scopeChain: [VO(innerTest), VO(test), VO(global)], // 作用域链

    this: {}

}

　　很多人会误解为当前作用域与上层作用域为包含关系，但其实并不是。以最前端为起点，最末端为终点的单方向通道我认为是更加贴切的形容。如图。

三、闭包

　　当函数可以记住并访问所在的作用域(全局作用域除外)时，就产生了闭包，即使函数是在当前作用域之外执行。简单来说，假设函数A在函数B的内部进行定义了，并且当函数A在执行时，访问了函数B内部的变量对象，那么B就是一个闭包。

　　我们知道，函数的执行上下文，在执行完毕之后，生命周期结束，那么该函数的执行上下文就会失去引用。其占用的内存空间很快就会被垃圾回收器释放。可是闭包的存在，会阻止这一过程。所以，通过闭包，我们可以在其他的执行上下文中，访问到函数的内部变量。

var fn = null;

function foo() {

    var a = 2;

    function innnerFoo() {

        console.log(a);

    }

    fn = innnerFoo; // 将 innnerFoo的引用，赋值给全局变量中的fn

}

function bar() {

    fn(); // 此处的保留的innerFoo的引用

}

foo();

bar(); //

　　在上面的例子中，foo()执行完毕之后，按照常理，其执行环境生命周期会结束，所占内存被垃圾收集器释放。但是通过fn = innerFoo，函数innerFoo的引用被保留了下来，复制给了全局变量fn。这个行为，导致了foo的变量对象，也被保留了下来。于是，函数fn在函数bar内部执行时，依然可以访问这个被保留下来的变量对象。所以此刻仍然能够访问到变量a的值。我们称foo为闭包。

四、闭包的常用场景

　　1、延迟函数setTimeout

function fn() {

    console.log('this is test.')

}

var timer = setTimeout(fn, 1000);

console.log(timer);

　　执行上面的代码，变量timer的值，会立即输出出来，表示setTimeout这个函数本身已经执行完毕了。但是一秒钟之后，fn才会被执行。这是为什么？

　　按道理来说，既然fn被作为参数传入了setTimeout中，那么fn将会被保存在setTimeout变量对象中，setTimeout执行完毕之后，它的变量对象也就不存在了。可是事实上并不是这样。至少在这一秒钟的事件里，它仍然是存在的。这正是因为闭包。

　　很显然，这是在函数的内部实现中，setTimeout通过特殊的方式，保留了fn的引用，让setTimeout的变量对象，并没有在其执行完毕后被垃圾收集器回收。因此setTimeout执行结束后一秒，我们任然能够执行fn函数。

　　2、模块

(function () {

    var a = 10;

    var b = 20;

    function add(num1, num2) {

        var num1 = !!num1 ? num1 : a;

        var num2 = !!num2 ? num2 : b;

        return num1 + num2;

    }

    window.add = add;

})();

add(10, 20);

　　上面的例子使用函数自执行的方式，创建了一个模块。add是模块对外暴露的一个公共方法。而变量a，b被作为私有变量。

　　在面向对象的开发中，我们常常需要考虑是将变量作为私有变量，还是放在构造函数中的this中，因此理解闭包，以及原型链是一个非常重要的事情。

　　3、柯里化
　　在函数式编程中，利用闭包能够实现很多炫酷的功能，柯里化算是其中一种。

五、留个问题，验证自己有没有理解闭包：

　　利用闭包，修改下面的代码，让循环输出的结果依次为1， 2， 3， 4， 5

for (var i=1; i<=5; i++) {

    setTimeout( function timer() {

        console.log(i);

    }, i*1000 );

}

　　5分钟后。。。

for(var i=1; i<=5; i++){

    (function(i){

        setTimeout(function timer(){

            console.log(i)

        }, i*1000);

    })(i);

}

巴特西

JS进阶之---作用域，作用域链，闭包

最新文章

热门文章