作用域和作用域链是javascript中非常重要的特征，关于他们的明白直接关系到关于悉数javascript系统的明白，而闭包又是对作用域的延长，也是在现实开辟中常常运用的一个特征，现实上，不仅仅是javascript，在许多言语中都供应了闭包的特征。

作用域

作用域是一个变量和函数的作用局限，javascript中函数内声明的一切变量在函数体内一直是可见的，在javascript中有全局作用域和部分作用域，然则没有块级作用域，部分变量的优先级高于全局变量，经由过程几个示例来相识下javascript中作用域的那些“潜划定规矩”（这些也是在前端口试中常常问到的题目）。
1. 变量声明提早
示例1：

var scope="global";
function scopeTest(){
    console.log(scope);
    var scope="local"  
}
scopeTest(); //undefined

此处的输出是undefined，并没有报错，这是因为在前面我们提到的函数内的声明在函数体内一直可见，上面的函数等效于：

var scope="global";
function scopeTest(){
    var scope;
    console.log(scope);
    scope="local"  
}
scopeTest(); //local

注重，假如遗忘var，那末变量就被声明为全局变量了。
2. 没有块级作用域
和其他我们经常使用的言语差别，在Javascript中没有块级作用域：

function scopeTest() {
    var scope = {};
    if (scope instanceof Object) {
        var j = 1;
        for (var i = 0; i < 10; i++) {
            //console.log(i);
        }
        console.log(i); //输出10
    }
    console.log(j);//输出1

}

在javascript中变量的作用局限是函数级的，即在函数中一切的变量在悉数函数中都有定义，这也带来了一些我们略不注重就会遇到的“潜划定规矩”：

var scope = "hello";
function scopeTest() {
    console.log(scope);//①
    var scope = "no";
    console.log(scope);//②
}

在①处输出的值竟然是undefined，几乎丧尽天良啊，我们已定义了全局变量的值啊，这处所不该该为hello吗？实在，上面的代码等效于：

var scope = "hello";
function scopeTest() {
    var scope;
    console.log(scope);//①
    scope = "no";
    console.log(scope);//②
}

声明提早、全局变量优先级低于部分变量，依据这两条划定规矩就不难明白为何输出undefined了。

作用域链

在javascript中，每一个函数都有本身的实行上下文环境，当代码在这个环境中实行时，会建立变量对象的作用域链，作用域链是一个对象列表或对象链，它保证了变量对象的有序接见。
作用域链的前端是当前代码实行环境的变量对象，常被称之为“活泼对象”，变量的查找会从第一个链的对象最先，假如对象中包括变量属性，那末就住手查找，假如没有就会继承向上级作用域链查找，直到找到全局对象中：

作用域链的逐级查找，也会影响到顺序的机能，变量作用域链越长对机能影响越大，这也是我们只管防止运用全局变量的一个重要原因。

闭包

• 基本观点

作用域是明白闭包的一个条件，闭包是指在当前作用域内老是能接见外部作用域中的变量。

function createClosure(){
    var name = "jack";
    return {
        setStr:function(){
            name = "rose";
        },
        getStr:function(){
            return name + ":hello";
        }
    }
}
var builder = new createClosure();
builder.setStr();
console.log(builder.getStr()); //rose:hello

上面的示例在函数中返回了两个闭包，这两个闭包都维持着对外部作用域的援用，因而不论在哪挪用老是能够接见外部函数中的变量。在一个函数内部定义的函数，会将外部函数的活泼对象添加到本身的作用域链中，因而上面实例中经由过程内部函数能够接见外部函数的属性，这也是javascript模拟私有变量的一种体式格局。

注重：因为闭包会分外的附带函数的作用域（内部匿名函数照顾外部函数的作用域），因而，闭包会比别的函数多占用些内存空间，过分的运用能够会致使内存占用的增添。

• 闭包中的变量
  在运用闭包时，因为作用域链机制的影响，闭包只能获得内部函数的末了一个值，这引发的一个副作用就是假如内部函数在一个轮回中，那末变量的值一直为末了一个值。

    //该实例不太合理，有肯定耽误要素，此处重要为了申明闭包轮回中存在的题目
    function timeManage() {
        for (var i = 0; i < 5; i++) {
            setTimeout(function() {
                console.log(i);
            },1000)
        };
    }

上面的顺序并没有根据我们预期的输入1-5的数字，而是5次悉数输出了5。再来看一个示例：

function createClosure(){
    var result = [];
    for (var i = 0; i < 5; i++) {
        result[i] = function(){
            return i;
        }
    }
    return result;
}

挪用createClosure()[0]()返回的是5，createClosure()[4]()返回值仍然是5。经由过程以上两个例子能够看出闭包在带有轮回的内部函数运用时存在的题目：因为每一个函数的作用域链中都保存着对外部函数（timeManage、createClosure）的活泼对象，因而，他们都援用着统一变量i，当外部函数返回时，此时的i值为5，所以内部的每一个函数i的值也为5。
那末怎样处理这个题目呢？我们能够经由过程匿名包裹器（匿名自实行函数表达式）来强迫返回预期的效果：

function timeManage() {
    for (var i = 0; i < 5; i++) {
        (function(num) {
            setTimeout(function() {
                console.log(num);
            }, 1000);
        })(i);
    }
}

或许在闭包匿名函数中再返回一个匿名函数赋值：

function timeManage() {
    for (var i = 0; i < 10; i++) {
        setTimeout((function(e) {
            return function() {
                console.log(e);
            }
        })(i), 1000)
    }
}
//timeManager();输出1,2,3,4，5
function createClosure() {
    var result = [];
    for (var i = 0; i < 5; i++) {
        result[i] = function(num) {
            return function() {
                console.log(num);
            }
        }(i);
    }
    return result;
}
//createClosure()[1]()输出1；createClosure()[2]()输出2

无论是匿名包裹器照样经由过程嵌套匿名函数的体式格局，原理上都是因为函数是按值通报，因而会将变量i的值复制给实参num，在匿名函数的内部又建立了一个用于返回num的匿名函数，如许每一个函数都有了一个num的副本，互不影响了。

• 闭包中的this

在闭包中运用this时要特别注重，轻微不慎能够会引发题目。一般我们明白this对象是运行时基于函数绑定的，全局函数中this对象就是window对象，而当函数作为对象中的一个要领挪用时，this即是这个对象（TODO 关于this做一次整顿）。因为匿名函数的作用域是全局性的，因而闭包的this一般指向全局对象window：

var scope = "global";
var object = {
    scope:"local",
    getScope:function(){
        return function(){
            return this.scope;
        }
    }
}

挪用object.getScope()()返回值为global而不是我们预期的local，前面我们说过闭包中内部匿名函数会照顾外部函数的作用域，那为何没有获得外部函数的this呢？每一个函数在被挪用时，都邑自动建立this和arguments，内部匿名函数在查找时，搜刮到活泼对象中存在我们想要的变量，因而住手向外部函数中的查找，也就永久不能够直接接见外部函数中的变量了。总之，在闭包中函数作为某个对象的要领挪用时，要特别注重，该要领内部匿名函数的this指向的是全局变量。
荣幸的是我们能够很简单的处理这个题目，只须要把外部函数作用域的this存放到一个闭包能接见的变量内里即可：

var scope = "global";
var object = {
    scope:"local",
    getScope:function(){
        var that = this;
        return function(){
            return that.scope;
        }
    }
}

object.getScope()()返回值为local。

• 内存与机能
  因为闭包中包括与函数运行期上下文雷同的作用域链援用，因而，会发生肯定的负面作用，当函数中活泼对象和运行期上下文烧毁时，因为必要仍存在对活泼对象的援用，致使活泼对象没法烧毁，这意味着闭包比一般函数占用更多的内存空间，在IE浏览器下还能够会致使内存走漏的题目，以下：

 function bindEvent(){
    var target = document.getElementById("elem");
    target.onclick = function(){
        console.log(target.name);
    }
 }

上面例子中匿名函数对外部对象target发生一个援用，只如果匿名函数存在，这个援用就不会消逝，外部函数的target对象也不会被烧毁，这就发生了一个轮回援用。处理方案是经由过程建立target.name副本削减对外部变量的轮回援用以及手动重置对象：

  function bindEvent(){
    var target = document.getElementById("elem");
    var name = target.name;
    target.onclick = function(){
        console.log(name);
    }
    target = null;
 }

闭包中假如存在对外部变量的接见，无疑增添了标识符的查找途径，在肯定的情况下，这也会形成机能方面的丧失。处理此类题目的方法我们前面也曾提到过：只管将外部变量存入到部分变量中，削减作用域链的查找长度。

总结：闭包不是javascript独占的特征，然则在javascript中有其奇特的表现形式，运用闭包我们能够在javascript中定义一些私有变量，以至模拟出块级作用域，但闭包在运用过程中，存在的题目我们也须要相识，如许才防止不必要题目的涌现。