JS：闭包 - JustBB

闭包（Closure） 是 JavaScript 中一个非常重要的概念，它允许函数访问其词法作用域中的变量，即使函数在其词法作用域之外执行。闭包的原理和意义在 JavaScript 开发中非常关键，以下是详细说明：

1. 闭包的原理

(1) 词法作用域

JavaScript 使用词法作用域（Lexical Scope），即函数的作用域在函数定义时就已经确定，而不是在函数调用时确定。
函数可以访问其定义时所处的作用域中的变量。

(2) 闭包的形成

当一个函数在其词法作用域之外执行时，仍然可以访问其词法作用域中的变量，这时就形成了闭包。
闭包的本质是函数与其词法作用域的结合。

(3) 闭包形成的条件

闭包的形成需要满足以下条件：

函数嵌套： 闭包通常发生在函数内部定义了另一个函数（即嵌套函数）。外层函数提供了一个作用域环境，内层函数可以访问这个环境。
内部函数引用外部变量： 内层函数必须引用外层函数作用域中的变量或参数。如果内层函数没有引用外层作用域的变量，就不会形成闭包。
外部函数返回内部函数： 外层函数需要将其内部函数返回，或者以某种方式将内部函数暴露出去（比如赋值给外部变量）。这样，内部函数可以在外部函数执行完毕后仍然被调用。
外部函数被调用且执行完成： 闭包的形成是在外层函数执行完毕后，内部函数依然能够“记住”外层函数作用域中的变量。这是由于 JavaScript 的作用域链和垃圾回收机制，外部变量不会被销毁，因为内部函数仍然持有对它们的引用。

示例：

function outer() {
    let count = 0; // 外层函数的变量
    function inner() { // 内层函数
        count++; // 引用外层变量
        console.log(count);
    }
    return inner; // 返回内层函数
}

const fn = outer(); // outer 执行并返回 inner
fn(); // 输出 1
fn(); // 输出 2

在这个例子中：

inner 函数引用了 outer 的变量 count。
outer 返回了 inner，使得 inner 可以在外部被调用。
即使 outer 执行完毕，count 依然被 inner “记住”，形成了闭包。

2. 闭包的意义

(1) 数据封装

闭包可以用于创建私有变量和方法，从而实现数据封装。
私有变量只能在闭包内部访问，外部无法直接修改或访问。

示例：

function createCounter() {
  let count = 0; // 私有变量

  return {
    increment() {
      count++;
    },
    getCount() {
      return count;
    }
  };
}

const counter = createCounter();
counter.increment();
console.log(counter.getCount()); // 输出: 1

在上面的例子中，count 是一个私有变量，只能通过 increment 和 getCount 方法访问和修改。

(2) 回调函数

闭包常用于回调函数中，确保回调函数可以访问定义时的上下文。

示例：

function fetchData(callback) {
  setTimeout(() => {
    const data = "Some data";
    callback(data);
  }, 1000);
}

function processData() {
  const prefix = "Processed: ";

  fetchData(function (data) {
    console.log(prefix + data); // 访问外部函数的变量
  });
}

processData(); // 输出: Processed: Some data

在上面的例子中，回调函数可以访问 processData 函数中的 prefix 变量。

(3) 函数柯里化

闭包可以用于实现函数柯里化（Currying），即将一个多参数函数转换为一系列单参数函数。

示例：

function add(a) {
  return function (b) {
    return a + b;
  };
}

const add5 = add(5); // 返回一个函数，a 被固定为 5
console.log(add5(10)); // 输出: 15

在上面的例子中，add5 是一个闭包，它记住了 a 的值（5）。

(4) 模块模式

闭包可以用于实现模块模式，将相关的变量和函数封装在一个作用域中，避免污染全局作用域。

示例：

const module = (function () {
  const privateVar = "I am private";

  function privateMethod() {
    console.log(privateVar);
  }

  return {
    publicMethod() {
      privateMethod();
    }
  };
})();

module.publicMethod(); // 输出: I am private

在上面的例子中，privateVar 和 privateMethod 是私有的，只能通过 publicMethod 访问。

3. 闭包的注意事项

(1) 内存泄漏

闭包会导致外部函数的变量无法被垃圾回收，从而可能导致内存泄漏。
如果不再需要闭包，应该手动解除引用。

示例：

function createHeavyClosure() {
  const largeArray = new Array(1000000).fill("data");

  return function () {
    console.log(largeArray[0]);
  };
}

let heavyFunc = createHeavyClosure();
heavyFunc(); // 使用闭包

// 不再需要时，解除引用
heavyFunc = null;

(2) 性能问题

闭包会增加作用域链的长度，从而可能影响性能。
在性能敏感的场景中，应谨慎使用闭包。