在 JavaScript 函数式编程中，闭包和柯里化是两个核心概念。它们不仅能让代码更灵活，还能解决许多实际开发中的问题。本文将从基础原理出发，结合实例代码详细解析，帮你彻底掌握这两个知识点。
一、闭包：函数与环境的「记忆纽带」🧠
1.1 什么是闭包？
闭包的核心定义：能够访问自由变量的函数。
- 自由变量：在函数内部使用，但既不是函数参数，也不是内部定义的变量（即来自外部作用域的变量）。
- 通俗理解：函数「记住」了它定义时所处的环境，即使在外部调用也能访问该环境中的变量。
1.2 闭包的工作原理
闭包的实现依赖于 JavaScript 的词法作用域（函数的作用域在定义时确定，而非调用时）和垃圾回收机制（闭包会保留外部变量不被回收）。
举个直观的例子：
function outer() {
const outerVar = "我是外部变量"; // 自由变量
function inner() {
console.log(outerVar); // 访问外部变量，形成闭包
}
return inner; // 返回内部函数
}
const closureFunc = outer();
closureFunc(); // 输出："我是外部变量"（即使outer已执行完毕，仍能访问outerVar）
1.3 闭包的典型应用场景
（1）数据私有化与封装
通过闭包隐藏内部状态，只暴露必要的操作方法：
function createBankAccount(initialMoney) {
let balance = initialMoney; // 私有变量，外部无法直接访问
return {
getBalance: () => balance, // 闭包：访问balance
deposit: (money) => balance += money,
withdraw: (money) => balance -= money
};
}
const account = createBankAccount(100);
account.deposit(50);
console.log(account.getBalance()); // 输出：150（无法直接修改balance）
（2）函数工厂（批量生成相似函数）
function createAdder(base) {
return function(num) {
return base + num; // base是自由变量
};
}
const add5 = createAdder(5);
const add10 = createAdder(10);
console.log(add5(3)); // 8
console.log(add10(3)); // 13
1.4 文档中的闭包实例解析
用闭包处理动态参数
function add() {
// arguments是函数运行时的参数集合（类数组）
const args = Array.from(arguments); // 转为真正的数组
let result = 0;
for(let i = 0; i < args.length; i++) {
result += args[i];
}
return result;
}
- 这里虽未直接体现闭包，但
arguments作为函数内部的特殊对象，其作用域与闭包的变量查找机制类似，都是基于函数执行时的环境。
二、柯里化：函数参数的「分步收集」📦
2.1 什么是柯里化？
柯里化（Currying）是将多参数函数转化为一系列单参数（或部分参数）函数的技术。
- 核心思想：不一次性传入所有参数，而是分多次传入，每次传入部分参数，直到参数集齐后执行函数。
- 类比：像收集七颗龙珠，集齐后才能召唤神龙（执行函数）。
2.2 柯里化的实现原理
核心目标：
- 逐步收集参数，直到参数数量等于原函数的参数个数（
fn.length）。 - 每次收集参数后返回一个新函数，继续等待接收剩余参数。
代码分步解析：
// 原函数：需要3个参数
function add(a, b, c) {
return a + b + c;
}
// 柯里化函数
function curry(fn) {
// 定义递归函数judge，用于收集参数
let judge = (...args) => {
// 条件1：如果收集的参数数量等于原函数需要的参数数量
if (args.length === fn.length) {
return fn(...args); // 执行原函数并返回结果
} else {
// 条件2：参数不足，返回新函数继续收集
return (...newArgs) => judge(...args, ...newArgs); // 合并已有参数和新参数
}
};
return judge; // 返回柯里化后的函数
}
// 使用柯里化
const addCurry = curry(add);
console.log(addCurry(1)(2)(3)); // 6（分3次传入参数）
console.log(addCurry(1, 2)(3)); // 6（分2次传入参数）
关键逻辑：
judge函数通过递归实现参数收集：每次接收新参数后，与已收集的参数合并。- 当参数总数达标时，触发原函数执行；否则继续返回新函数等待参数。
2.3 柯里化的变体实例
如果函数需要支持任意次数传参（不限于原函数参数个数），可以修改逻辑：
function add(...args) {
console.log("当前收集的参数：", args);
return (...newArgs) => {
const allArgs = [...args, ...newArgs]; // 合并所有参数
console.log("合并后参数：", allArgs);
// 此处可添加执行条件，例如参数长度>=3时执行
if (allArgs.length >= 3) {
return allArgs.reduce((a, b) => a + b, 0);
}
return add(...allArgs); // 继续收集参数
};
}
// 示例：分2次传入6个参数
add(1, 2, 3)(4, 5, 6);
// 输出：
// 当前收集的参数：[1,2,3]
// 合并后参数：[1,2,3,4,5,6]
2.4 柯里化的优缺点
优点：
- 灵活性：可以根据场景分步骤传参，适配不同的调用方式。
- 复用性：固定部分参数后，可生成新的函数（例如
addCurry(10)固定第一个参数为 10，后续只需传剩余参数）。 - 延迟执行：允许在参数未集齐时暂不执行，等待合适时机。
缺点：
- 增加了函数嵌套层级，可能影响代码可读性。
- 递归调用可能带来轻微的性能损耗（在参数较少时可忽略）。
三、函数参数处理技巧：从类数组到动态收集 🛠️
3.1 处理不定参数：arguments对象
arguments是函数内部的特殊对象，包含所有传入的参数，但它是类数组（有length属性，但无数组方法）。
转换为真正的数组：
function add() {
// 方法1：Array.from()
const args1 = Array.from(arguments);
// 方法2：扩展运算符
const args2 = [...arguments];
// 方法3：Array.prototype.slice.call()
const args3 = Array.prototype.slice.call(arguments);
return args1.reduce((a, b) => a + b, 0);
}
console.log(add(1, 2, 3, 4)); // 10
3.2 更简洁的方式：REST 参数
ES6 的...args（REST 参数）可以直接将参数转为数组，替代arguments：
function add(...args) { // 直接获取数组形式的参数
console.log(args); // [1,2,3]（第一次调用）
return (...newArgs) => {
const allArgs = [...args, ...newArgs]; // 合并参数
console.log(allArgs); // [1,2,3,4,5,6]（第二次调用）
};
}
add(1, 2, 3)(4, 5, 6);
- 优势：语法更简洁，且天生就是数组，可直接使用
map、reduce等方法。
四、闭包与柯里化的关联与区别 🔗
| 特性 | 闭包 | 柯里化 |
|---|---|---|
| 核心作用 | 保留函数定义时的环境 | 分步收集参数 |
| 实现基础 | 词法作用域 + 函数嵌套 | 函数返回函数 + 递归 |
| 典型应用 | 数据私有化、防抖节流 | 参数复用、延迟执行 |
| 关联 | 柯里化依赖闭包实现参数记忆（每次收集的参数通过闭包保存） |
五、总结与实践建议 📝
-
闭包是 JavaScript 的天然特性，合理使用可实现数据封装和状态记忆（如防抖、节流函数）。
-
柯里化是函数式编程的重要技巧，适合参数较多且需要分步传入的场景（如表单验证、API 请求参数预处理）。
-
实际开发中，不必过度柯里化，避免嵌套过深导致代码晦涩。
-
掌握
arguments和 REST 参数的转换与使用，能更灵活地处理动态参数。
通过本文的解析，相信你对闭包和柯里化的理解已经从「知道」升级为「会用」。尝试在项目中实践这些技巧，让代码更优雅、更具扩展性吧！💻
