JavaScript 闭包

闭包是指在JavaScript中，一个函数可以访问其词法作用域之外的变量的能力。简单来说，闭包是由函数以及在函数创建时所存在的词法环境组成的。

当一个函数内部定义了另一个函数，并且内部函数引用了外部函数的变量时，就形成了闭包。通过闭包，内部函数可以访问和操作外部函数的变量，即使外部函数已经执行完毕，这些变量仍然可用。

下面是一个闭包的示例：

```javascript
function outer() {
  var name = "John";

  function inner() {
    console.log("Hello, " + name + "!");
  }

  return inner; // 返回内部函数
}

var greet = outer(); // 调用外部函数，并将内部函数赋值给变量
greet(); // 输出: Hello, John!
```

在上面的示例中，`outer`函数返回了内部函数`inner`，然后将其赋值给变量`greet`。当调用`greet`函数时，它仍然能够访问`outer`函数中的`name`变量，尽管`outer`函数已经执行完毕并返回了。这是因为`inner`函数形成了闭包，保留了对`outer`函数的词法环境的引用，包括其中的变量。

闭包的特点和优势包括：
- 可以访问外部函数的变量和参数。
- 可以保留对外部函数作用域的引用，即使外部函数已经执行完毕。
- 可以用于创建私有变量和函数。
- 可以实现柯里化（Currying）和函数工厂等功能。

需要注意的是，闭包可能导致内存占用较高，因为它会一直保存对外部函数的引用。如果闭包过多或被错误使用，可能会导致内存泄漏问题。因此，在使用闭包时，需要注意合理管理内存和避免不必要的引用。

以下是一些闭包的示例：

1. 计数器：

```javascript
function createCounter() {
  var count = 0;

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

  return increment;
}

var counter = createCounter();
counter(); // 输出: 1
counter(); // 输出: 2
counter(); // 输出: 3
```

在这个示例中，`createCounter`函数返回了内部函数`increment`。`increment`函数可以访问并修改`createCounter`函数作用域中的`count`变量。每次调用`counter`函数时，都会增加计数器的值，并输出新的计数。

2. 私有变量：

```javascript
function createPerson(name) {
  var age = 30;

  return {
    getName: function() {
      return name;
    },
    getAge: function() {
      return age;
    },
    setAge: function(newAge) {
      age = newAge;
    }
  };
}

var person = createPerson("John");
console.log(person.getName()); // 输出: John
console.log(person.getAge()); // 输出: 30
person.setAge(35);
console.log(person.getAge()); // 输出: 35
```

在这个示例中，`createPerson`函数返回了一个包含三个方法的对象。这些方法可以访问和修改`createPerson`函数作用域中的`name`和`age`变量。由于这些变量在闭包中被引用，外部无法直接访问或修改它们，从而实现了私有性。

3. 循环中的闭包：

```javascript
function createPrintFunctions() {
  var numbers = [1, 2, 3, 4, 5];

  var printFunctions = [];

  for (var i = 0; i < numbers.length; i++) {
    var number = numbers[i];
    printFunctions.push(function() {
      console.log(number);
    });
  }

  return printFunctions;
}

var printFunctions = createPrintFunctions();
printFunctions[0](); // 输出: 1
printFunctions[1](); // 输出: 2
printFunctions[2](); // 输出: 3
```

在这个示例中，`createPrintFunctions`函数返回一个函数数组`printFunctions`。在循环中，我们创建了多个函数，每个函数都引用了不同的`number`变量。当我们调用`printFunctions`数组中的函数时，它们分别输出对应的数字。这是因为每个函数都形成了闭包，保留了在创建时的`number`变量的引用。

这些示例展示了不同场景下使用闭包的方式。通过闭包，可以实现许多有用的功能，例如创建私有变量和函数、封装状态以及创建函数工厂等。