说说你对闭包的理解？

一、什么是闭包？

闭包（Closure）是指函数与其词法作用域的组合，它使函数可以“记住”并访问其定义时的词法作用域，即使该函数在其作用域之外被调用。

关键点：

• 词法作用域： 函数在其定义的位置决定了其可以访问的变量，而不是调用的位置。
• 持久化环境： 内层函数始终保存对外层函数变量的引用。

function outerFunction() {
	let outerVariable = "I'm from outer!";
	return function innerFunction() {
		console.log(outerVariable);
	};
}

const myClosure = outerFunction();
myClosure(); // 输出：I'm from outer!

特性：

1. 闭包使得函数可以记住其定义时的环境。
2. 即使外层函数已执行完毕，其内部变量依然存在于内存中（因为闭包引用了它们）。

二、闭包的使用场景

1. 创建私有变量

闭包常用于隐藏数据，仅通过指定的接口访问。

function Counter() {
	let count = 0; // 私有变量
	return {
		increment: () => ++count,
		decrement: () => --count,
		getCount: () => count
	};
}

const counter = Counter();
console.log(counter.increment()); // 1
console.log(counter.getCount()); // 1
console.log(counter.decrement()); // 0

应用场景：

• 模拟类的私有变量。
• 提高模块化代码的安全性。

2. 柯里化（函数参数复用）

柯里化通过闭包实现，将多参数函数转化为嵌套的一元函数，提升代码灵活性。

function currySum(a) {
	return function (b) {
		return function (c) {
			return a + b + c;
		};
	};
}

console.log(currySum(1)(2)(3)); // 输出：6

应用场景：

• 配置函数：为一组参数复用提供便利。
• 延迟执行：将函数调用拆分为多个步骤。

---

3. 延长变量生命周期

闭包延长了变量的生命周期，可以在异步代码或事件处理中保持对外层变量的引用。

function createDelayedLogger(message) {
	return function () {
		setTimeout(() => console.log(message), 1000);
	};
}

const logger = createDelayedLogger('Hello, Closure!');
logger(); // 延迟1秒后输出：Hello, Closure!

应用场景：

• 异步操作的回调函数。
• 创建定制化事件处理器。

---

4. 缓存（记忆化）

通过闭包保存计算结果，以提高函数的性能。

function memoize(fn) {
	const cache = {};
	return function (...args) {
		const key = JSON.stringify(args);
		if (!cache[key]) {
			cache[key] = fn(...args);
		}
		return cache[key];
	};
}

const factorial = memoize((n) => (n <= 1 ? 1 : n * factorial(n - 1)));
console.log(factorial(5)); // 120
console.log(factorial(5)); // 缓存结果：120

应用场景：

• 性能优化：如递归函数、大量重复运算等。

三、注意事项

1. 内存泄漏问题：
   由于闭包会导致外部变量的引用始终存在，可能导致内存无法被及时释放。

   解决方法：

   • 避免在闭包中引用不必要的外部变量。
   • 在不需要闭包时，手动清除引用。

   let outer = (function () {
   	let privateVar = 0;
   	return function () {
   		return privateVar;
   	};
   })();
   
   outer = null; // 手动释放闭包的引用
   

2. 性能影响：
   过多使用闭包可能导致内存占用增加（因为闭包会一直持有其外层函数的作用域）。

3. 不要滥用闭包：
   在可以通过简单逻辑解决问题时，不要强行使用闭包。