JavaScript中有两个“链”，即原型链与作用域链，前者关于实现继承，prototype。而后者对于理解闭包至关重要。

在这之前，我们大慨过一遍，非闭包情况下的作用域链。

概念

前端基础进阶（二）：执行上下文详细图解
JS的作用域和作用域链
结合代码图文讲解JavaScript中的作用域与作用域链

执行环境（（Execution Context）

执行环境（execution context）是JavaScript中最为重要的一个概念，执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。每个执行环境都有一个与之关联的变量对象（variable object），环境定义的所有变量和函数都保存了这个对象中。虽然我们编写的代码无法访问这个对象，但解析器会在处理数据时会在后台使用它
————《JS高程》

执行环境的数据结构类似stack，遇到不同的环境，如函数时，就会推入栈中，但是栈底永远是全局执行环境，JavaScript中的全局执行环境当然是window对象。

var a = "variable a";
console.log(window.a);      // "variable a"

function A() {
    console.log("something");       
}

window.A();              // "something"

在未执行A函数前，Global就是全局对象，因为是函数声明，在变量未被赋值前，函数A就会存在于Global对象中，这涉及到JS引擎的解析过程，这也从另一方面解释了函数与变量提升这一知识点。
总之，函数声明会在变量赋值之前就准备好，这在JS预解析时发生的行为。
下一步，才是赋值行为。

因为函数声明永远会比变量赋值提前，所以，同名的函数声明和变量，变量永远会覆盖函数。

var fn = "fn";
function fn() {
    console.log("Function fn");
}

fn();       // ???

这里会发生什么？当然是报错。TypeError: fn is not a function，因为fn被重新赋值了，已经不是函数了。

回到刚才。

但是，内部的函数永远可以访问外部全局环境中的变量和函数，依托的就是作用域链。

以这段代码为例，我大慨画一下作用域链形成。

var c = "outer c";

function A() {
    var a = "inner a";
    console.log(c);
}

A();                // "outer c"
console.log(a);     // a is not defined

A函数进栈前

window对象保存着全局作用域下的各种方法和属性。

A函数进栈后

从图中，我们可以看出，为什么在函数A中可以找到全局变量c，就是因为作用域链的访问关系，A函数首先在自己内部寻找变量c，如果没有自有变量，那么沿着作用域链向下寻找，最后在全局作用域里找到变量c。但是作用域链的访问不可逆，在全局作用域中是无法逆作用域去访问变量a的。

关于JS查询标识符相关内容可以在《JS高程》4.2.2一节中找到。

变量对象和活动对象是什么？

在《JS高程》里，是这样描述的。

当代码在一个环境中执行时，会创建变量对象的一个作用域链（scope chain）。作用域链的用途，是保证对执行环境有权访问的所有变量和函数的有序访问（注意这个有权和有序）。作用域链的前端，始终都是当前执行的代码所在环境的变量对象。如果这个环境是函数，则将其活动对象（activation object）作为变量对象。活动对象在最开始只包含一个变量，即arguments变量（这个对象在全局作用域中是不存在的）。
作用域链中的下一个变量对象来自包含（外部）环境，再下一个变量对象则来自下一个包含环境。这样，一直延续到全局执行环境；全局执行环境的变量对象始终都是作用域链的最后一个对象。
标识符解析是沿着作用域链一级一级地搜索标识符的过程。搜索过程始终从作用域链的前端开始（本身作用域），然后逐级向后回溯，直至找到标识符为止（如果找不到标识符，通常会导致错误发生）。

函数内部所有的变量和函数都保存在一个叫做变量对象中（这部分是隐式的），变量对象被调用的时候就称之为活动对象，变量对象里面如果还有（函数）变量对象他们之间需要访问的这个时候又被称之为作用域链！一层层到全局执行环境！
————知乎用户：败笔

所以，变量对象就是执行环境中定义的变量、函数和undefined。而活动对象则是变量对象在不同解析过程时的名称变动，本质是一个东西。

当A函数执行完毕后，A函数退出执行环境，内部的局部变量就没有存在的必要了，局部活动对象就会被销毁，内存中仅保存全局作用域，即window对象（全局执行环境的变量对象）。

到此为止，我们粗略的过了一遍函数执行时，其内部的大致情况。但是，闭包就有所不同了。

概念：闭包是指有权访问另一个函数作用域中变量的函数

由此可得，闭包，是一个函数。

用书中栗子

function createComparisonFunction(propertyName) {

    return function(object1,object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];        

        if (value1 < value2) {
            return -1;
        } else if (value1 > value2) {
            return 1;
        } else {
            return 0;
        }  
    };
}

var compare = createComparisonFunction("name");

var obj1 = {name:"Nicholas"};
var obj2 = {name:"Greg"};
var result = compare(obj1,obj2);

在另一个函数内部定义的函数会将函数（即外部函数）的活动对象添加到它的作用域链中。因此，在createComparisonFunction()函数内部定义的匿名函数的作用域链中，实际上会包含外部函数createComparisonFunction()的活动对象。

这句话的意思就是，内部的匿名函数可以访问到createComparisonFunction()函数内部的变量对象，也就可以访问到内部的值。
这没什么好难理解的对吧，访问可以由内而外，不可以由外而内，这在作用域链里是写死了的。

在匿名函数从createComparisonFunction()中被返回后，它的作用域链被初始化为包含createComparisonFunction()函数的活动对象和全局变量对象，这样，匿名函数可以访问在createComparisonFunction()中定义的所有变量。
更为重要的是，createComparisonFunction()函数在执行完毕后，其活动对象也不会被销毁，因为匿名函数仍然在引用这个活动对象。换句话说，createComparisonFunction()函数执行完毕并返回后，它的执行环境的作用域链会被销毁，但它的活动对象仍留在内存中；直至匿名函数被销毁后，createComparisonFunction()的活动对象才会被销毁。

调用createComparisonFunction()过程中作用域链的关系

也就是说，createComparisonFunction()函数执行完毕后，它的活动对象因为匿名函数的引用，不会被销毁，createComparisonFunction()函数返回的匿名函数被全局变量result引用着（result引用匿名函数），这样，就构成了一个闭包。

其实闭包挺好玩的，能从外部访问到内部函数的变量

var global = function() {
    var g = "G";
    
    return function() {
        return g;
    }
}

var test = global();
var test2 = test();

自己写了一个自己也看不懂的......

var fn = function () {
    var fn2 = function () {
        var target = "Target";

        return function() {
            return target;
        }
    }

    return fn2();

};

var test = fn();    // 闭包函数
console.log(test());    // 访问闭包内的引用变量

closure(fn2)也说明了，这个闭包指向的是函数fn2，变量target。

我们还可以使用多个闭包。

var fn = function () {
    var fn = "fn";
    var fn2 = function () {
        var target = "Target";

        return function() {
            console.log(target + fn);
        }
    }

    return fn2;
};

var test = fn();
var test2 = test();
test2();

这张图能很好的说明，每个函数中是否存在闭包，引用了谁。

也可以用闭包隐藏一个变量

var test = (function() {
    var num = 123;
    return function() {
        return num;
    }
})();

console.log(test());    // 123

推荐文章：What is the Execution Context & Stack in JavaScript? by David Shariff