闭包

函数和对其周围状态（lexical environment，词法环境）的引用捆绑在一起构成闭包（closure）。

也就是说，闭包可以让你从内部函数访问外部函数作用域。在 JavaScript 中，每当函数被创建，就会在函数生成时生成闭包。

词法作用域

function init() {
    // 局部创建的变量 name
    let name = 'Mozilla';
    // displayName 是内部函数，一个闭包
    function displayName() {
        // 使用了父函数中声明的变量
        console.log(name);
    }
    displayName();
}
init();

示例 1

记住闭包定义：闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量

所以在本例中，myFunc 是执行 makeFunc 时创建的 displayName 函数实例的引用，displayName 的实例维持了一个对它自己的词法环境的引用，变量 name 存在于该词法环境中,因此当 myFunc 被调用时，变量 name 仍然可用

function makeFunc() {
    let name = 'Mozilla';
    function displayName() {
        console.log(name);
    }
    return displayName;
}
let myFunc = makeFunc();
myFunc();

示例 2

add5 和 add10 都是闭包。它们共享相同的函数定义，但是保存了不同的词法环境。在 add5 的环境中，x 为 5。而在 add10 中，x 则为 10。

function makeAdder(x) {
    return function (y) {
        return x + y;
    };
}
let add5 = makeAdder(5);
let add10 = makeAdder(10);
add5(2); // 7
add10(2); // 12

实用的闭包

通常当你使用只有一个方法的对象的地方，都可以使用闭包。例：调整页面字号

function makeSizer(size) {
    return function () {
        document.body.style.fontSize = size + 'px';
    };
}
let size12 = makeSizer(12);
let size14 = makeSizer(14);
let size16 = makeSizer(16);
document.getElementById('size-12').onclick = size12;
document.getElementById('size-14').onclick = size14;
document.getElementById('size-16').onclick = size16;

用闭包模拟私有方法

此处我们只创建了一个词法环境，为三个函数所共享：Counter.increment、Counter.decrement、Counter.value

该共享环境创建于一个立即执行的匿名函数体内，这个环境中包含两个私有项：名为 privateCounter 的变量和名为 changeBy 的函数，这两项都无法在这个匿名函数外部直接访问。必须通过匿名函数返回的三个公共函数访问。

let Counter = (function () {
    let privateCounter = 0;
    function changeBy(val) {
        privateCounter += val;
    }
    return {
        increment: function () {
            changeBy(1);
        },
        decrement: function () {
            changeBy(-1);
        },
        value: function () {
            return privateCounter;
        },
    };
})();
Counter.value(); // 0
Counter.increment();
Counter.increment();
Counter.value(); // 2
Counter.decrement();
Counter.value(); // 1

性能考量

如果不是某些特定任务需要使用闭包，在其它函数中创建函数是不明智的，因为闭包在处理速度和内存消耗方面对脚本性能具有负面影响。

例如，在创建新的对象或者类时，方法通常应该关联于对象的原型，而不是定义到对象的构造器中。

原因是这将导致每次构造器被调用时，方法都会被重新赋值一次（也就是说，对于每个对象的创建，方法都会被重新赋值）。

# 闭包

# 词法作用域

# 示例 1

# 示例 2

# 实用的闭包

# 用闭包模拟私有方法