各位编程爱好者，下午好！
今天，我们将深入探讨 JavaScript 中两个核心且强大的概念：闭包（Closure） 和 立即执行函数表达式（IIFE – Immediately Invoked Function Expression）。这两个看似简单的特性，在实际开发中却能发挥出令人惊叹的魔力，尤其是在实现 私有变量 和 单例模式 方面。作为一名编程专家，我将带大家从基础概念出发，逐步揭示它们的工作原理，并通过丰富的代码示例，展示它们在构建健壮、可维护的应用程序中的实战价值。
一、理解基石：JavaScript 中的作用域
在深入闭包和 IIFE 之前，我们必须牢固掌握 JavaScript 中的作用域概念。作用域决定了变量和函数的可访问性，是理解这些高级模式的基石。
JavaScript 中主要有以下几种作用域：
-
全局作用域 (Global Scope)
在代码的任何地方都可以访问的变量和函数，它们在程序启动时创建，在程序结束时销毁。全局作用域中的变量过多会导致命名冲突和代码污染。// globalVariable 在全局作用域中 const globalVariable = "I am global"; function greetGlobal() { console.log(globalVariable); } greetGlobal(); // I am global console.log(globalVariable); // I am global -
函数作用域 (Function Scope)
在函数内部声明的变量和函数，只能在该函数内部及其嵌套函数中访问。函数执行完毕后，其内部的局部变量通常会被销毁（除非被闭包引用）。这是 JavaScript 在 ES6 之前最主要的私有作用域机制。function myFunction() { const functionVariable = "I am inside a function"; console.log(functionVariable); // I am inside a function } myFunction(); // console.log(functionVariable); // ReferenceError: functionVariable is not defined -
块级作用域 (Block Scope)
ES6 引入let和const关键字后，JavaScript 拥有了块级作用域。这意味着在if语句、for循环、while循环或任何{}块中声明的变量，只在该块内部有效。if (true) { let blockVariable = "I am inside a block"; const anotherBlockVariable = "Me too!"; console.log(blockVariable); // I am inside a block console.log(anotherBlockVariable); // Me too! } // console.log(blockVariable); // ReferenceError: blockVariable is not defined // console.log(anotherBlockVariable); // ReferenceError: anotherBlockVariable is not defined for (let i = 0; i < 3; i++) { // i 仅在循环内部有效 console.log(`Loop iteration: ${i}`); } // console.log(i); // ReferenceError: i is not defined
理解这些作用域的层次和生命周期至关重要，因为闭包正是利用了函数作用域的这种特性。
下表总结了不同关键字声明变量的作用域特点：
| 关键字 | 作用域类型 | 变量提升 (Hoisting) | 可重复声明 | 可重新赋值 |
|---|---|---|---|---|
var |
函数作用域/全局 | 是 | 是 | 是 |
let |
块级作用域 | 否 (暂时性死区) | 否 | 是 |
const |
块级作用域 | 否 (暂时性死区) | 否 | 否 |
二、揭秘闭包：函数与其“记住”的环境
闭包是 JavaScript 中一个强大而又容易让人困惑的概念。但一旦理解，你会发现它无处不在，是许多高级模式的基础。
2.1 什么是闭包？
MDN Web Docs 对闭包的定义是：“闭包是函数和声明该函数的词法环境的组合。”
用更通俗的语言来说：当一个函数能够记住并访问其词法作用域（也就是它被创建时的作用域）中的变量，即使该函数在其词法作用域之外被调用时，它仍然能够做到这一点，那么这个函数就是一个闭包。
核心思想： 一个内部函数可以访问其外部函数的变量，即使外部函数已经执行完毕并从调用栈中移除。这是因为内部函数“捕获”了外部函数的变量环境。
2.2 闭包的工作原理
让我们通过一个经典的计数器例子来理解闭包：
function createCounter() {
let count = 0; // count 是 createCounter 的局部变量
function increment() {
count++; // increment 访问并修改了 count
console.log(count);
}
return increment; // 返回内部函数
}
const counter1 = createCounter(); // counter1 是 increment 函数的一个实例
const counter2 = createCounter(); // counter2 是 increment 函数的另一个独立实例
counter1(); // 输出: 1
counter1(); // 输出: 2
counter2(); // 输出: 1 (独立的计数器)
counter1(); // 输出: 3 (counter1 继续计数)解析：
createCounter()函数被调用，创建了一个局部变量count并初始化为0。createCounter()返回了内部函数increment。- 当
createCounter()执行完毕后，它的执行上下文会被销毁。通常情况下，count变量也应该随之消失。 - 然而，
counter1和counter2都引用了increment函数。increment函数在被创建时，捕获了其外部作用域（即createCounter的作用域）中的count变量。 - 因此，尽管
createCounter已经执行完毕，increment函数仍然能够“记住”并访问它所引用的count变量。每次调用counter1()或counter2()时，它们各自的count变量都会被独立地修改。
这就是闭包的魔力：它允许函数携带其创建环境的状态。
2.3 闭包的常见应用场景
- 数据私有化与封装： 这是我们今天重点讨论的主题之一。
- 模拟私有方法： 与私有变量类似，可以创建外部无法直接访问的内部方法。
- 柯里化 (Currying)： 创建一个函数，该函数接收部分参数，并返回一个新函数，新函数继续接收剩余参数。
- 函数工厂： 根据不同的参数创建和返回定制化的函数。
- 模块模式： 在 ES6 模块出现之前，闭包和 IIFE 是实现模块化最常用的方式。
- 事件处理程序和回调函数： 它们经常作为闭包存在，捕获其定义时的环境。
三、IIFE：立即执行的私有作用域
了解了闭包，我们再来看另一个强大的工具：立即执行函数表达式 (Immediately Invoked Function Expression – IIFE)。
3.1 什么是 IIFE？
IIFE 是一种 JavaScript 函数，它在定义后立即执行。它的主要目的是创建私有作用域，从而避免污染全局作用域。
基本语法结构：
(function() {
// 你的代码
})();或者：
(function() {
// 你的代码
}());解析：
function() { ... }：这是一个普通的匿名函数表达式。(function() { ... })：外层的括号将函数声明转换为一个函数表达式。在 JavaScript 中，只有函数表达式才能被立即调用。如果直接写function() {}()，解析器会将其视为函数声明，并报错。()：紧跟在函数表达式后面的这对括号表示立即调用这个函数。
3.2 为什么使用 IIFE？
在 ES6 模块化（import/export）普及之前，IIFE 是 JavaScript 中实现模块化、隔离作用域、避免全局变量污染的核心手段。
-
创建私有作用域： IIFE 内部声明的所有变量和函数都是局部的，不会暴露到全局作用域，有效避免了命名冲突。
// 没有 IIFE 的情况 // var message = "Hello Global!"; // 污染全局 // 使用 IIFE (function() { var message = "Hello from IIFE!"; // 局部变量 console.log(message); })(); // console.log(message); // ReferenceError: message is not defined -
封装代码： 将一组相关的代码封装在一个独立的单元中，提高代码的可读性和维护性。
-
避免变量提升问题： 使用
var声明的变量会发生变量提升，导致一些意想不到的行为。在 IIFE 内部使用var，它的提升范围也仅限于 IIFE 内部。 -
模块模式的基础： IIFE 是实现经典 JavaScript 模块模式的基础，通过 IIFE 返回一个包含公共接口的对象。
3.3 IIFE 的参数传递
IIFE 也可以接收参数，这在某些场景下非常有用，例如向其内部传递全局对象或其他库的引用。
(function(global, $) {
// global 指向 window 对象
// $ 指向 jQuery 对象
console.log('Inside IIFE:');
console.log('Global object:', global === window); // true
// console.log('jQuery object:', $); // 如果页面引入了jQuery，这里会打印jQuery对象
var privateVar = "This is private within IIFE";
console.log(privateVar);
})(window, jQuery); // 假设 jQuery 已经被引入这种模式常用于大型库中，通过局部变量引用全局变量（如 window 或 jQuery），可以提高查找效率，并避免外部代码对全局变量的修改影响到 IIFE 内部的引用。
四、实战应用一：利用闭包实现私有变量
JavaScript 在 ES6 类私有字段出现之前，并没有内置的“私有”成员机制。但通过闭包，我们可以优雅地模拟出私有变量，实现数据的封装和信息隐藏。
4.1 私有变量的必要性
在面向对象编程中，私有变量是实现封装（Encapsulation）的关键。它们有以下优点：
- 数据保护： 防止外部代码随意修改对象内部的状态，保证数据一致性。
- 控制访问： 只能通过公共方法（getter/setter）来访问和修改私有变量，从而可以在访问过程中添加验证逻辑。
- 隐藏实现细节： 外部代码无需知道内部变量的具体实现，只需关注公共接口。
4.2 传统 JavaScript 对象的问题
考虑一个简单的对象：
const user = {
name: "Alice",
age: 30
};
console.log(user.age); // 30
user.age = -5; // 外部可以直接修改，没有验证
console.log(user.age); // -5这里 age 属性可以直接被修改为无效值，缺乏保护。即使我们约定使用下划线前缀 (_age) 来表示私有，那也只是一种约定，无法强制执行。
4.3 使用闭包和 IIFE 实现私有变量
结合 IIFE 和闭包，我们可以创建一个构造函数或工厂函数，使其生成的对象拥有真正的“私有”状态。
我们将创建一个 Person 工厂函数，它能生成 Person 对象，其中 age 属性是私有的。
/**
* Person 工厂函数，利用闭包实现私有变量
* @param {string} initialName - 初始姓名
* @param {number} initialAge - 初始年龄
* @returns {object} 包含公共方法的 Person 对象
*/
function createPerson(initialName, initialAge) {
// 1. 私有变量
// 这些变量在 createPerson 函数的作用域内，
// 外部无法直接访问，但内部的 getter/setter 方法可以通过闭包访问它们。
let name = initialName;
let age = initialAge; // 这是我们希望私有的变量
// 2. 私有方法 (可选，但同样通过闭包实现)
function validateAge(newAge) {
if (typeof newAge === 'number' && newAge >= 0 && newAge <= 150) {
return true;
}
console.warn(`Invalid age value: ${newAge}. Age must be between 0 and 150.`);
return false;
}
// 3. 返回一个包含公共接口的对象
// 这些公共方法构成了对私有变量的唯一访问途径
return {
getName: function() {
return name; // 闭包访问私有变量 name
},
setName: function(newName) {
if (typeof newName === 'string' && newName.trim() !== '') {
name = newName.trim(); // 闭包修改私有变量 name
} else {
console.warn("Invalid name. Name must be a non-empty string.");
}
},
getAge: function() {
return age; // 闭包访问私有变量 age
},
setAge: function(newAge) {
if (validateAge(newAge)) { // 调用私有方法进行验证
age = newAge; // 闭包修改私有变量 age
}
},
introduce: function() {
console.log(`Hi, my name is ${name} and I am ${age} years old.`);
}
};
}
// 使用工厂函数创建 Person 对象
const person1 = createPerson("Alice", 30);
const person2 = createPerson("Bob", 25);
console.log("--- Person 1 ---");
person1.introduce(); // Hi, my name is Alice and I am 30 years old.
console.log("Person 1's age (via getter):", person1.getAge()); // 30
// 尝试直接访问私有变量 (会失败)
// console.log(person1.age); // undefined
// person1.age = 100; // 这不会修改内部的私有 age 变量，而是创建了一个新的公共属性
// console.log(person1.getAge()); // 仍然是 30
// 通过公共方法修改私有变量
person1.setAge(31);
person1.setName("Alicia");
person1.introduce(); // Hi, my name is Alicia and I am 31 years old.
// 尝试设置一个无效的年龄
person1.setAge(-10); // Warn: Invalid age value: -10. Age must be between 0 and 150.
person1.introduce(); // Age remains 31
console.log("n--- Person 2 ---");
person2.introduce(); // Hi, my name is Bob and I am 25 years old.
person2.setAge(26);
person2.introduce(); // Hi, my name is Bob and I am 26 years old.
// 证明两个 Person 实例的私有变量是独立的
person1.introduce(); // Hi, my name is Alicia and I am 31 years old.工作原理详解：
createPerson是一个普通的函数，当它被调用时，会创建一个新的执行上下文。- 在这个执行上下文内部，
let name和let age被声明。它们是createPerson函数的局部变量。 createPerson返回一个对象，这个对象包含了getName,setName,getAge,setAge,introduce等方法。- 这些返回的方法都是在
createPerson内部定义的，因此它们都形成了闭包，捕获了createPerson作用域中的name和age变量。 - 即使
createPerson函数执行完毕，它的局部变量name和age也不会被垃圾回收，因为它们被返回的那些闭包方法所引用。 - 外部代码只能通过返回的公共方法来间接访问和修改
name和age。直接通过person1.age访问只会得到undefined，或者在对象上创建一个新的公共属性，而不会影响到闭包内部的私有age。 - 每次调用
createPerson，都会创建一个新的name和age变量以及一套新的闭包方法，因此person1和person2实例拥有独立的私有状态。
这种模式在 JavaScript 中被称为 模块模式（Module Pattern） 或 揭示模块模式（Revealing Module Pattern） 的变体，它通过闭包实现了强大的数据封装。
4.4 结合 IIFE 实现更彻底的私有化
如果我们希望一个对象只有唯一的实例，或者其私有变量不依赖于每次创建实例时的参数，而是更像一个“模块”的私有状态，那么 IIFE 可以与闭包结合，提供更强大的封装。
这里我们创建一个“银行账户”模块，其内部的 balance 是完全私有的。
/**
* 银行账户模块，利用 IIFE 和闭包实现私有余额和公共方法
*/
const bankAccount = (function() {
// 1. 私有变量
// 仅在 IIFE 的作用域内可见，外部无法直接访问
let balance = 0; // 账户余额，是私有的
// 2. 私有方法 (可选)
function isValidAmount(amount) {
return typeof amount === 'number' && amount > 0;
}
// 3. 返回一个包含公共接口的对象
return {
deposit: function(amount) {
if (isValidAmount(amount)) {
balance += amount;
console.log(`Deposited ${amount}. New balance: ${balance}`);
} else {
console.warn("Deposit failed: Invalid amount.");
}
},
withdraw: function(amount) {
if (isValidAmount(amount)) {
if (balance >= amount) {
balance -= amount;
console.log(`Withdrew ${amount}. New balance: ${balance}`);
} else {
console.warn(`Withdraw failed: Insufficient funds. Current balance: ${balance}`);
}
} else {
console.warn("Withdraw failed: Invalid amount.");
}
},
getBalance: function() {
return balance; // 通过闭包访问私有变量
},
// 尝试暴露一个私有变量的引用，看看会发生什么
// getBalanceReference: function() { return balance; } // 这样返回的是值副本，不是引用
};
})(); // IIFE 立即执行，bankAccount 接收到返回的公共接口对象
// 使用银行账户模块
console.log("Initial balance:", bankAccount.getBalance()); // 0
bankAccount.deposit(100); // Deposited 100. New balance: 100
bankAccount.withdraw(30); // Withdrew 30. New balance: 70
bankAccount.deposit(200.50); // Deposited 200.5. New balance: 270.5
console.log("Current balance:", bankAccount.getBalance()); // 270.5
// 尝试直接访问私有变量 (会失败)
// console.log(bankAccount.balance); // undefined
// bankAccount.balance = 1000000; // 这不会修改 IIFE 内部的私有 balance
// console.log(bankAccount.getBalance()); // 仍然是 270.5
bankAccount.withdraw(300); // Withdraw failed: Insufficient funds. Current balance: 270.5
bankAccount.deposit(-50); // Deposit failed: Invalid amount.在这个例子中：
balance变量被声明在 IIFE 内部，因此它是一个私有变量，在 IIFE 外部是无法直接访问的。deposit,withdraw,getBalance方法在 IIFE 内部定义，形成闭包，它们可以访问并操作balance变量。- IIFE 立即执行并返回一个对象，这个对象包含了所有公共方法。
bankAccount变量接收的就是这个公共接口对象。 - 这样就创建了一个具有私有状态的模块，外部只能通过模块提供的公共方法与之交互，从而实现了严格的数据封装。
五、实战应用二：利用闭包实现单例模式
单例模式（Singleton Pattern）是设计模式中最简单但也最常用的模式之一。它的核心思想是：保证一个类只有一个实例，并提供一个全局访问点来获取这个实例。
5.1 单例模式的必要性
在许多场景下，我们只需要一个对象实例，例如：
- 配置管理器： 整个应用程序只需要一个配置对象来加载和管理各种设置。
- 日志记录器 (Logger)： 通常只需要一个日志实例来记录应用程序的事件。
- 数据库连接池： 避免频繁创建和销毁数据库连接，提高性能。
- 事件总线/消息中心： 统一管理应用程序的事件发布和订阅。
5.2 传统对象创建的问题
如果我们不使用单例模式，每次需要一个 Logger 时，都可能会创建一个新的实例：
class Logger {
constructor() {
console.log("Logger instance created.");
this.logs = [];
}
log(message) {
const timestamp = new Date().toISOString();
this.logs.push(`[${timestamp}] ${message}`);
console.log(`LOG: ${message}`);
}
getLogs() {
return this.logs;
}
}
const logger1 = new Logger(); // Logger instance created.
logger1.log("App started.");
const logger2 = new Logger(); // Logger instance created. (又创建了一个新实例)
logger2.log("User logged in.");
console.log(logger1.getLogs()); // 只有 'App started.'
console.log(logger2.getLogs()); // 只有 'User logged in.'
// 两个 logger 实例的日志是独立的，这不是我们想要的单例行为。5.3 使用闭包和 IIFE 实现单例模式
通过结合 IIFE 和闭包，我们可以创建一个“单例工厂”，确保无论调用多少次，都只返回同一个实例。
/**
* Logger 单例模式实现
* 保证 Logger 只有一个实例，并提供全局访问点
*/
const Logger = (function() {
// 1. 私有变量：用于存储唯一的实例
let instance;
// 2. 私有构造函数：定义 Logger 实例的实际结构和行为
// 这是一个内部函数，外部无法直接访问
function LoggerConstructor() {
console.log("Logger: Initializing new instance...");
this.logs = []; // 存储日志的数组
this.id = Math.random().toString(36).substring(2, 9); // 给实例一个随机ID
}
// 3. 私有方法：Logger 实例的方法
LoggerConstructor.prototype.log = function(message) {
const timestamp = new Date().toISOString();
this.logs.push(`[${timestamp}] ${message}`);
console.log(`[${this.id}] LOG: ${message}`);
};
LoggerConstructor.prototype.getLogs = function() {
return this.logs;
};
LoggerConstructor.prototype.getId = function() {
return this.id;
};
// 4. 返回一个公共方法（获取单例实例的方法）
// 这个方法形成了闭包，可以访问并操作 `instance` 变量
return {
getInstance: function() {
// 检查是否已经存在实例
if (!instance) {
// 如果不存在，则创建新实例
instance = new LoggerConstructor();
}
// 返回已存在的或新创建的实例
return instance;
}
};
})(); // IIFE 立即执行，Logger 变量接收到的是一个包含 getInstance 方法的对象
// 使用单例 Logger
const loggerA = Logger.getInstance(); // Logger: Initializing new instance...
loggerA.log("Application started.");
loggerA.log("User 'John' logged in.");
const loggerB = Logger.getInstance(); // 不会再次输出 "Initializing new instance..."
loggerB.log("User 'Jane' logged out.");
console.log("n--- Verifying Singleton ---");
console.log("Logger A ID:", loggerA.getId()); // 应该与 Logger B ID 相同
console.log("Logger B ID:", loggerB.getId()); // 应该与 Logger A ID 相同
console.log("Are loggerA and loggerB the same instance?", loggerA === loggerB); // true
console.log("n--- All Logs ---");
console.log(loggerA.getLogs());
/*
[
'[2023-10-27T...Z] Application started.',
'[2023-10-27T...Z] User 'John' logged in.',
'[2023-10-27T...Z] User 'Jane' logged out.'
]
*/
// 验证通过 loggerB 也能访问到 loggerA 写入的日志
console.log(loggerB.getLogs()); // 与 loggerA.getLogs() 结果相同工作原理详解：
- IIFE 封装： 整个单例逻辑被包裹在一个 IIFE 中，这创建了一个私有作用域。
instance变量和LoggerConstructor函数都只在这个 IIFE 内部可见，不会污染全局。 instance变量：let instance;被声明在 IIFE 的私有作用域内。它将被用来存储单例的唯一实例。由于它在 IIFE 内部，外部无法直接访问或修改它。LoggerConstructor： 这是一个普通的构造函数，定义了 Logger 实例的实际结构和方法。它是私有的，外部无法直接通过new LoggerConstructor()来创建实例。getInstance方法（闭包）： IIFE 返回一个包含getInstance方法的对象。这个getInstance方法是一个闭包，它捕获了 IIFE 作用域中的instance变量。- 单例逻辑：
- 第一次调用
Logger.getInstance()时，instance变量是undefined。 if (!instance)条件为真，new LoggerConstructor()会被调用，创建一个新的 Logger 实例，并将其赋值给instance。- 此后每次调用
Logger.getInstance()时，instance已经有了值。 if (!instance)条件为假，getInstance直接返回已经存在的instance。
- 第一次调用
- 结果： 无论
Logger.getInstance()被调用多少次，它总是返回最初创建的那个 Logger 实例。
5.4 单例模式的优缺点
优点：
- 资源节约： 避免重复创建对象，特别是在对象创建成本较高时（如数据库连接、线程池）。
- 统一访问点： 提供一个全局唯一的访问点，方便管理和协调。
- 状态共享： 多个部分可以共享同一个实例的状态，便于数据同步。
缺点：
- 全局依赖： 单例模式创建了一个全局可访问的实例，可能导致紧耦合，使其成为一个全局的隐式依赖。
- 测试困难： 由于其全局性，在单元测试中替换或模拟单例对象变得困难。
- 违反单一职责原则： 单例对象既负责自己的业务逻辑，又负责保证自己的唯一性。
- 可伸缩性问题： 在分布式系统或需要多实例的场景下，单例模式可能不适用。
在现代 JavaScript 开发中，随着 ES6 模块和依赖注入等概念的普及，单例模式的使用需要更加谨慎。但它仍然是理解 JavaScript 封装机制和设计模式的重要一环。
六、现代 JavaScript 中的替代方案与演进
闭包和 IIFE 在过去是 JavaScript 中实现私有变量和模块化、单例模式的基石。然而，随着语言的发展，ES6+ 引入了一些新的特性，为解决相同问题提供了更直接、更简洁的语法。
6.1 ES6 模块 (Modules)
ES6 模块是实现代码封装和组织的首选方式。每个模块都有自己的私有作用域，只有通过 export 导出的内容才能被外部访问。这从语言层面提供了比 IIFE 更优雅的私有化机制。
// myModule.js
let privateData = "This is module private data."; // 模块私有变量
function privateHelper() { // 模块私有函数
console.log("Private helper used.");
}
export function publicMethod() {
privateHelper();
return `Accessing private data: ${privateData}`;
}
export const PUBLIC_CONSTANT = "I am public.";
// app.js
import { publicMethod, PUBLIC_CONSTANT } from './myModule.js';
console.log(publicMethod()); // Private helper used. Accessing private data: This is module private data.
console.log(PUBLIC_CONSTANT); // I am public.
// console.log(myModule.privateData); // Error: myModule is not defined, privateData is not exported在模块内部声明的变量和函数默认就是私有的，只有通过 export 关键字显式导出的才是公共接口。这使得模块化和私有化变得更加直观。
6.2 ES2019+ 类私有字段 (Class Private Fields)
ES2019 引入了真正的类私有字段，使用 # 前缀来声明。这为类提供了原生的私有成员机制，不再需要依赖闭包来模拟。
class Person {
#name; // 私有字段
#age; // 私有字段
constructor(name, age) {
this.#name = name;
this.#age = age;
}
getName() {
return this.#name;
}
getAge() {
return this.#age;
}
#validateAge(newAge) { // 私有方法
return typeof newAge === 'number' && newAge >= 0 && newAge <= 150;
}
setAge(newAge) {
if (this.#validateAge(newAge)) {
this.#age = newAge;
} else {
console.warn(`Invalid age: ${newAge}`);
}
}
introduce() {
console.log(`Hi, my name is ${this.#name} and I am ${this.#age} years old.`);
}
}
const person = new Person("Charlie", 40);
person.introduce(); // Hi, my name is Charlie and I am 40 years old.
// 尝试直接访问私有字段 (会报错)
// console.log(person.#name); // SyntaxError: Private field '#name' must be declared in an enclosing class
// person.#age = 50; // SyntaxError
person.setAge(41);
person.introduce(); // Hi, my name is Charlie and I am 41 years old.
person.setAge(-5); // Warn: Invalid age: -5类私有字段提供了语法上的保证，使得私有成员在类外部真正不可访问，这比基于闭包的模拟私有变量更加严格和直观。
6.3 闭包和 IIFE 的地位
尽管有了新的语言特性，闭包和 IIFE 并没有失去它们的价值：
- 理解基础： 它们是 JavaScript 核心机制的体现，理解它们有助于深入理解语言的运行方式。
- 兼容性： 在不支持 ES6+ 新特性的旧环境中，它们仍然是实现封装和模块化的有效手段。
- 函数式编程： 闭包在函数式编程范式中扮演着核心角色，如柯里化、高阶函数等。
- 灵活性： 闭包的强大之处在于其能够“捕获”任意作用域的状态，实现非常灵活的数据封装和状态管理，这在某些复杂场景下可能比类私有字段更具弹性。
- 模块模式的演进： 许多现代前端框架和库的内部实现仍然大量依赖闭包来管理状态和创建组件。单例模式也依然可以使用闭包实现，特别是在非类结构中。
七、核心思想与现代实践的融合
闭包和 IIFE 是 JavaScript 中不可或缺的基石。它们利用了 JavaScript 的词法作用域特性，为我们提供了强大的工具来实现数据封装、私有变量、模块化以及单例模式等设计模式。
尽管现代 JavaScript 引入了 ES6 模块和类私有字段等更简洁、更原生的方式来解决类似问题，但深入理解闭包和 IIFE 的工作原理，对于任何有志于成为优秀 JavaScript 开发者的人来说，仍然至关重要。它们不仅是理解语言深层机制的关键，更是构建健壮、可维护、高性能应用程序的宝贵技能。在实际开发中，我们应根据项目需求、团队规范和目标环境的兼容性，灵活选择最合适的实现方式，并将这些核心概念融会贯通到日常编码实践中。