我们先来看一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
function outerFunction() {
    var outerVariable = "我是外部变量";

    function innerFunction() {
        console.log(outerVariable); // 这里可以访问 outerVariable
    }

    return innerFunction;
}

var myClosure = outerFunction();
myClosure(); // 输出 "我是外部变量"

在这个例子中，有两个函数：outerFunction 和 innerFunction。innerFunction 是在 outerFunction 里面定义的。当我们调用 outerFunction 时，它返回 innerFunction，并且 innerFunction 记住了 outerVariable 的值。

详细解释

  1. 定义外部函数（outerFunction）：

    1
    2
    function outerFunction() {
        var outerVariable = "我是外部变量";

    这里我们定义了一个外部函数，里面有一个变量 outerVariable。

  2. 定义内部函数（innerFunction）：

    1
    2
    3
    function innerFunction() {
        console.log(outerVariable); // 这里可以访问 outerVariable
    }

    在 outerFunction 里面，我们又定义了一个内部函数 innerFunction，它可以访问并打印 outerVariable。

  3. 返回内部函数：

    1
    2
    return innerFunction;
    }

    outerFunction 返回 innerFunction，让我们可以在外部调用它。

  4. 调用外部函数并保存返回的内部函数：

    1
    var myClosure = outerFunction();

    我们调用 outerFunction，并把返回的 innerFunction 保存到变量 myClosure 中。

  5. 调用闭包函数：

    1
    myClosure(); // 输出 "我是外部变量"

    最后，我们调用 myClosure，它实际上就是 innerFunction，所以会输出 outerVariable 的值——“我是外部变量”。

为什么有用？

闭包非常有用，因为它可以让我们创建私有变量和函数。举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function createCounter() {
    var count = 0;

    function increment() {
        count++;
        console.log(count);
    }

    return increment;
}

var myCounter = createCounter();
myCounter(); // 输出 1
myCounter(); // 输出 2
myCounter(); // 输出 3

在这个例子中，count 是 createCounter 函数中的一个变量，但是通过闭包，我们可以在外部访问并修改 count 的值，而不直接暴露 count。