闭包：编程世界的“潘多拉魔盒”，打开它，世界从此不同！
各位程序猿、攻城狮、代码界的艺术家们，晚上好！我是你们的老朋友，人称“bug终结者”的码农老王。今天，我们要一起探索编程世界里一个既神秘又强大的概念——闭包（Closures）。
闭包，听起来是不是有点高深莫测？别担心，老王今天就用最通俗易懂的语言，把这个“潘多拉魔盒”彻底打开，让你们领略它的魅力，掌握它的力量。
一、 什么是闭包？别怕，这玩意儿没那么吓人！
想象一下，你是一个魔法师🧙♂️，你创造了一个魔法咒语（函数），这个咒语可以召唤出特定的元素（变量）。现在，你把这个咒语传授给了你的学徒，但同时，你还告诉他，这个咒语只能影响你创造时的那些元素，即使环境发生了变化，咒语的效果也不会改变。
这就是闭包！
更专业一点的说法是：闭包是指函数与其周围状态（词法环境）的捆绑。 换句话说，闭包允许函数访问并操作函数外部的变量，即使在外部函数已经执行完毕后，这些变量仍然可以被访问。
是不是感觉有点抽象？没关系，我们来举个例子：
function outerFunction(x) {
let outerVar = x; // 外部变量
function innerFunction(y) {
return outerVar + y; // 内部函数访问外部变量
}
return innerFunction;
}
let myClosure = outerFunction(10); // 创建一个闭包
let result = myClosure(5); // 调用闭包
console.log(result); // 输出：15在这个例子中，innerFunction 就是一个闭包。它被定义在 outerFunction 内部，并且访问了 outerFunction 的变量 outerVar。即使 outerFunction 已经执行完毕，innerFunction 仍然可以访问 outerVar 的值。
关键点：
- 函数嵌套： 闭包通常涉及函数嵌套，一个函数定义在另一个函数内部。
- 外部变量访问： 内部函数可以访问外部函数的变量。
- 状态保持： 即使外部函数执行完毕，闭包仍然保持对外部变量的访问权限，并保持这些变量的状态。
二、 闭包的“前世今生”：为什么要有闭包？
闭包的出现，是为了解决一个很实际的问题：如何让函数拥有“记忆”能力？
在没有闭包之前，函数执行完毕后，所有的局部变量都会被销毁，函数就像一个“用完就扔”的工具。但有时候，我们需要函数能够记住一些信息，以便在下次调用时使用。
闭包就像一个“时光胶囊”，它把函数创建时的环境状态封装起来，让函数即使在不同的时间、不同的地点被调用，也能“回忆”起当初的状态。
举个例子：
假设我们要创建一个计数器，每次调用计数器函数，计数器的值都会加1。如果没有闭包，我们只能使用全局变量来实现：
let counter = 0; // 全局变量
function increment() {
counter++;
return counter;
}
console.log(increment()); // 输出：1
console.log(increment()); // 输出：2
console.log(increment()); // 输出：3这样做的问题是，counter 是一个全局变量，任何代码都可以修改它，这很容易导致错误。
使用闭包，我们可以这样实现：
function createCounter() {
let counter = 0; // 局部变量
function increment() {
counter++;
return counter;
}
return increment;
}
let myCounter = createCounter(); // 创建一个计数器
console.log(myCounter()); // 输出：1
console.log(myCounter()); // 输出：2
console.log(myCounter()); // 输出：3在这个例子中，counter 是 createCounter 函数的局部变量，只有 increment 函数可以访问它。这样就避免了全局变量的污染，提高了代码的安全性。
三、 闭包的“七十二变”：常见应用场景
闭包的应用场景非常广泛，几乎在任何需要“记忆”状态的地方，都可以看到它的身影。
- 模块化开发：
闭包可以用来创建模块，将一些变量和函数封装在一个模块内部，只暴露必要的接口给外部使用。这样可以避免全局变量的污染，提高代码的可维护性。
let myModule = (function() {
let privateVar = "秘密";
function privateFunction() {
console.log("我是私有函数");
}
return {
publicFunction: function() {
console.log("我是公共函数，我可以访问私有变量：" + privateVar);
privateFunction();
}
};
})();
myModule.publicFunction(); // 输出：我是公共函数，我可以访问私有变量：秘密
// myModule.privateVar; // 报错：undefined
// myModule.privateFunction(); // 报错：undefined在这个例子中，privateVar 和 privateFunction 是模块的私有成员，只能在模块内部访问。publicFunction 是模块的公共接口，可以被外部调用。
- 事件处理：
在事件处理中，闭包可以用来保存事件发生时的状态。
<!DOCTYPE html>
<html>
<head>
<title>闭包事件处理示例</title>
</head>
<body>
<button id="myButton">点击我</button>
<script>
function createClickHandler(message) {
return function() {
alert(message);
};
}
let button = document.getElementById("myButton");
button.onclick = createClickHandler("Hello, Closure!");
</script>
</body>
</html>在这个例子中，createClickHandler 函数返回一个闭包，这个闭包保存了 message 的值。当按钮被点击时，闭包会被执行，弹出 message 的值。
- 柯里化（Currying）：
柯里化是一种将接受多个参数的函数转换为接受单个参数的函数序列的技术。闭包可以用来实现柯里化。
function curry(fn) {
let arity = fn.length; // 函数需要的参数个数
return function f1(...args) {
if (args.length >= arity) {
return fn(...args); // 参数足够，执行函数
} else {
return function f2(...moreArgs) {
let newArgs = args.concat(moreArgs);
return f1(...newArgs); // 参数不足，返回一个新的函数，继续收集参数
};
}
};
}
function add(x, y, z) {
return x + y + z;
}
let curriedAdd = curry(add);
console.log(curriedAdd(1)(2)(3)); // 输出：6
console.log(curriedAdd(1, 2)(3)); // 输出：6
console.log(curriedAdd(1)(2, 3)); // 输出：6
console.log(curriedAdd(1, 2, 3)); // 输出：6在这个例子中，curry 函数将 add 函数柯里化，使其可以接受单个参数的函数序列。
- 数据封装和隐藏：
闭包可以用来实现数据封装和隐藏，将一些数据隐藏在函数内部，只暴露必要的接口给外部使用。
function createBankAccount(initialBalance) {
let balance = initialBalance; // 私有变量
return {
deposit: function(amount) {
balance += amount;
return balance;
},
withdraw: function(amount) {
if (amount > balance) {
return "余额不足";
}
balance -= amount;
return balance;
},
getBalance: function() {
return balance;
}
};
}
let myAccount = createBankAccount(100);
console.log(myAccount.deposit(50)); // 输出：150
console.log(myAccount.withdraw(20)); // 输出：130
console.log(myAccount.getBalance()); // 输出：130
// myAccount.balance; // 报错：undefined在这个例子中，balance 是银行账户的私有变量，只能通过 deposit、withdraw 和 getBalance 方法来访问。
- 迭代器：
闭包可以用来创建迭代器，用于遍历数据集合。
function createIterator(items) {
let index = 0;
return {
next: function() {
let done = index >= items.length;
let value = !done ? items[index++] : undefined;
return {
done: done,
value: value
};
}
};
}
let myArray = [1, 2, 3];
let myIterator = createIterator(myArray);
console.log(myIterator.next()); // 输出：{ done: false, value: 1 }
console.log(myIterator.next()); // 输出：{ done: false, value: 2 }
console.log(myIterator.next()); // 输出：{ done: false, value: 3 }
console.log(myIterator.next()); // 输出：{ done: true, value: undefined }在这个例子中，createIterator 函数返回一个迭代器，这个迭代器可以遍历 items 数组。
四、 闭包的“副作用”：内存泄漏问题
闭包虽然强大，但也并非完美无缺。它最大的问题就是可能导致内存泄漏。
由于闭包会保持对外部变量的引用，如果这些外部变量不再被使用，但闭包仍然存在，那么这些变量就无法被垃圾回收器回收，从而导致内存泄漏。
举个例子：
function outerFunction() {
let largeArray = new Array(1000000).fill(0); // 一个很大的数组
function innerFunction() {
console.log("innerFunction executed");
}
return innerFunction;
}
let myClosure = outerFunction(); // 创建一个闭包
myClosure(); // 执行闭包
// 现在，即使我们不再使用 myClosure，largeArray 仍然存在于内存中，因为它被 myClosure 引用着在这个例子中，largeArray 是一个很大的数组，它被 innerFunction 引用着。即使我们不再使用 myClosure，largeArray 仍然存在于内存中，因为它被 myClosure 引用着，导致内存泄漏。
如何避免内存泄漏？
- 及时释放引用： 在不再需要闭包时，将其设置为
null，解除对外部变量的引用。 - 避免过度使用闭包： 只有在确实需要“记忆”状态时才使用闭包。
- 使用弱引用（WeakRef）： 如果需要引用一个对象，但又不想阻止垃圾回收器回收它，可以使用弱引用。
五、 闭包的“葵花宝典”：使用技巧和最佳实践
- 理解词法作用域： 闭包的基础是词法作用域，理解词法作用域是理解闭包的关键。
- 避免循环中的闭包： 在循环中使用闭包时，要特别小心，避免出现意外的结果。
// 错误示例
for (var i = 0; i < 5; i++) {
setTimeout(function() {
console.log(i); // 输出：5 5 5 5 5
}, 1000);
}
// 正确示例
for (let i = 0; i < 5; i++) {
setTimeout(function() {
console.log(i); // 输出：0 1 2 3 4
}, 1000);
}
// 或者
for (var i = 0; i < 5; i++) {
(function(j) {
setTimeout(function() {
console.log(j); // 输出：0 1 2 3 4
}, 1000);
})(i);
}- 使用 IIFE（Immediately Invoked Function Expression）： IIFE 可以用来创建私有作用域，避免全局变量的污染。
(function() {
let privateVar = "秘密";
console.log("IIFE executed");
})();
// console.log(privateVar); // 报错：undefined- 善用调试工具： 使用浏览器的调试工具，可以帮助你理解闭包的执行过程。
六、 总结：闭包，你值得拥有！
闭包是编程世界里一个非常强大而灵活的概念。它允许函数拥有“记忆”能力，可以用来实现模块化开发、事件处理、柯里化、数据封装和隐藏等功能。
当然，闭包也有一些缺点，比如可能导致内存泄漏。但只要我们掌握了闭包的原理，并遵循一些最佳实践，就可以避免这些问题，充分发挥闭包的优势。
希望今天的讲解能帮助大家更好地理解闭包，掌握闭包的力量。记住，闭包就像一个“潘多拉魔盒”，打开它，你将会发现一个全新的编程世界！ 🚀
最后，留一个小作业：
请用闭包实现一个简单的计算器，可以进行加、减、乘、除运算。
期待你们的精彩答案！ 😉
感谢大家的聆听，我们下期再见！