维基百科对柯里化的定义是：
In mathematics and computer science, currying is the technique of translating a function that takes multiple arguments into a sequence of families of functions, each taking a single argument.
意思是：在数学和计算机科学中，柯里化是一种将“接收多个参数的函数”转换成“一系列接收单个参数的函数”的技术。
直观地看：
// 普通函数：一次性传入所有参数
function add(a, b, c) {
return a + b + c;
}
add(1, 2, 3); // 6
// 柯里化后的函数：分多次传入参数
const curriedAdd = curry(add);
curriedAdd(1)(2)(3); // 6
curriedAdd(1, 2)(3); // 6
严格意义上的柯里化通常要求“每一层函数只接收一个参数”。但 JavaScript 工具库里的 curry 往往会做增强，允许一次传入多个参数，所以 curriedAdd(1, 2)(3) 这种混合调用也很常见。
假设有一个日志函数：
function log(date, importance, message) {
console.log(`[${date.toISOString()}] [${importance}] ${message}`);
}
使用柯里化后，可以提前固定一部分参数，生成更适合当前业务场景的函数：
const curriedLog = curry(log);
const logNow = curriedLog(new Date());
const logInfoNow = logNow("INFO");
logInfoNow("用户登录成功");
logInfoNow("数据加载完毕");
这里的时间和日志级别被保存在闭包中，后续调用只需要传入真正变化的 message。
当参数还没收集够时，柯里化函数不会立即执行原函数，而是返回一个新函数继续等待参数。这让它很适合用于事件绑定、异步回调、配置预置等场景。
柯里化经常和 map、filter、reduce 这类高阶函数结合，让代码更接近“声明式表达”。
const prop = curry((key, obj) => obj[key]);
const users = [
{ id: 1, name: "Alice", age: 24 },
{ id: 2, name: "Bob", age: 28 },
{ id: 3, name: "Charlie"
下面从简单版本开始，一步步实现一个更接近 Lodash.curry 使用体验的版本。
如果只处理两个参数的函数，柯里化就是一个闭包嵌套：
function curryTwoArgs(fn) {
return function (a) {
return function (b) {
return fn(a, b);
};
};
}
function add(a, b) {
return a + b;
}
const curriedAdd = curryTwoArgs(add
这个版本只能处理两个参数。如果原函数有 3 个、4 个甚至更多参数，就不能继续手写固定层数了。
fn.length 与递归JavaScript 函数对象有一个 length 属性，用来表示函数期望接收的形参数量。
function sum(a, b, c) {}
console.log(sum.length); // 3
基于 fn.length，可以写出一个通用版本：
function curryV2(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args);
}
return function (...nextArgs) {
return curried.apply(this, args.concat(nextArgs
测试一下：
function sum3(a, b, c) {
return a + b + c;
}
const curriedSum = curryV2(sum3);
console.log(curriedSum(1, 2, 3)); // 6
console.log(curriedSum(1)(2)(3)); // 6
这个版本已经可以覆盖很多日常场景。
不过要注意：fn.length 不统计剩余参数，也会被默认参数影响。
function withDefault(a, b = 2, c) {}
console.log(withDefault.length); // 1
因此，完全依赖 fn.length 时，带默认值的函数可能会比你想象中更早执行。后面的 V4 会提供一个手动指定参数个数的方案。
有时我们不想严格从左到右传参，而是希望先固定第一和第三个参数，把第二个参数留到后面：
const _ = curry.placeholder;
const curriedFn = curry(fn);
curriedFn(1, _, 3)(2);
这就需要在收集参数时保留“坑位”。下一次调用时，新参数会优先填补之前的占位符。
一个初版实现如下：
function curryV3(fn) {
return function curried(...args) {
const _ = curryV3.placeholder;
const validArgs = args.filter((arg) => arg !== _);
if (validArgs.length >= fn.length) {
return fn.apply(this, args);
}
它能处理一些常规情况：
const _ = curryV3.placeholder;
function greet(greeting, name, punctuation) {
return `${greeting}, ${name}${punctuation}`;
}
const curriedGreet = curryV3(greet);
console.log(curriedGreet("Hello", "John",
但它的判断条件有漏洞：只检查“有效参数数量”是否足够，不检查“前 fn.length 个位置是否都已经填好”。
curriedGreet(_, _, _, "Hello", "John", "!");
这个调用里有效参数数量已经够了，但前三个位置仍然是占位符。V3 会提前执行原函数，导致错误结果。在这个例子中，因为模板字符串不能直接拼接 Symbol，所以会抛出 TypeError。
完善版需要解决三个问题：
arity 个参数都不是占位符时，才执行原函数。shift() 把未填的占位符变成 undefined。实现如下：
function curryV4(fn, arity = fn.length) {
return function curried(...args) {
const _ = curryV4.placeholder;
const isComplete =
args.length >= arity &&
args.slice(0, arity).every((arg) => arg !== _);
if (isComplete
这里的 arity 表示“需要收集多少个参数后再执行”。默认值是 fn.length，但你也可以手动指定。
const _ = curryV4.placeholder;
function greet(greeting, name, punctuation) {
return `${greeting}, ${name}${punctuation}`;
}
const curriedGreet = curryV4(greet);
console.log(curriedGreet("Hello", "John",
即使出现大量占位符，也不会提前执行：
console.log(
curriedGreet(_, _, _, "Hello", "John", "!")(_, _, _, "Hello", "John", "!")(
"Hello",
"John",
"!",
),
); // "Hello, John!"
默认参数会影响 fn.length：
function joinWithDefault(a, b = "B", c = "C") {
return `${a}-${b}-${c}`;
}
console.log(joinWithDefault.length); // 1
如果使用默认的 fn.length，传入第一个参数后就会执行：
const curriedJoinFast = curryV4(joinWithDefault);
console.log(curriedJoinFast("A")); // "A-B-C"
如果希望它像三参数函数一样继续收集参数，可以手动指定 arity：
const curriedJoin = curryV4(joinWithDefault, 3);
console.log(curriedJoin("A")("X")("Y")); // "A-X-Y"
console.log(curriedJoin("A", _, "Y")("X")); // "A-X-Y"
console.log(curriedJoin("A")(undefined)
这里传入 undefined 会触发 JavaScript 默认参数机制，所以 b 仍然取默认值 "B"。
后台管理系统中，经常需要写各种规则校验：
function check(reg, errMsg, value) {
if (!reg.test(value)) {
console.warn(errMsg);
return false;
}
return true;
}
不使用柯里化时，每次都要传入正则和提示语：
check(/^1[3-9]\d{9}$/, "手机号格式不正确", "13800138000");
check(/^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]
使用柯里化后，可以提前固化规则：
const curriedCheck = curryV4(check);
const checkPhone = curriedCheck(/^1[3-9]\d{9}$/, "手机号格式不正确");
const checkEmail = curriedCheck(
/^[\w-]+(\.[\w-]+)*@[-
业务层只需要关心用户输入，正则和错误提示都已经被闭包保存起来。
const prop = curryV4((key, obj) => obj[key]);
const users = [
{ id: 1, name: "Alice", age: 24 },
{ id: 2, name: "Bob", age: 28 },
{ id: 3, name: "Charlie"
users.map(prop("name")) 的意图很直接：从每个用户对象中取出 name 属性。
function request(baseUrl, method, path) {
return fetch(`${baseUrl}${path}`, { method }).then((res) => res.json());
}
const curriedRequest = curryV4(request);
const myApi = curriedRequest(
这个例子里，基础域名和请求方法都可以提前固定，业务代码只需要传入接口路径。
下面是一组可以直接用 Node.js 运行的测试，覆盖普通调用、混合调用、占位符、极端占位符、默认参数等情况。
const assert = require("node:assert/strict");
function curryV4(fn, arity = fn.length) {
return function curried(...args) {
const _ = curryV4.placeholder;
const isComplete =
args.length >= arity &&
args.slice(0, arity).every((arg) arg _
柯里化的核心是：把一次性接收多个参数的函数，改造成可以分阶段接收参数的函数。
从实现角度看，关键点有三个：
如果原函数没有默认参数，直接使用 curryV4(fn) 通常就够了。如果原函数存在默认参数，并且你希望它继续收集后面的参数，可以使用 curryV4(fn, arity) 手动指定参数个数。