JavaScript函数柯里化[编辑 | 编辑源代码]

函数柯里化（Currying）是函数式编程中的一种重要技术，它将一个接受多个参数的函数转换为一系列只接受单个参数的函数。柯里化后的函数可以逐步传递参数，并在最终收集所有参数后执行计算。这种技术提高了函数的灵活性和复用性，尤其在需要部分应用参数的场景中非常有用。

基本概念[编辑 | 编辑源代码]

柯里化的名称来源于数学家 Haskell Curry，他提出了这一概念。柯里化的核心思想是：将一个多参数函数分解为多个单参数函数的嵌套调用。例如，一个函数 f(a, b, c) 经过柯里化后，可以写成 f(a)(b)(c)。

数学上，柯里化可以表示为： $f : (A \times B \times C) \to D 转换为 f : A \to (B \to (C \to D))$

柯里化 vs 部分应用[编辑 | 编辑源代码]

柯里化与部分应用（Partial Application）容易混淆，但两者不同：

柯里化：将多参数函数转换为一系列单参数函数。
部分应用：固定一个函数的部分参数，生成一个接受剩余参数的新函数。

JavaScript 中的柯里化实现[编辑 | 编辑源代码]

手动柯里化[编辑 | 编辑源代码]

以下是一个简单的加法函数及其柯里化版本：

// 普通加法函数
function add(a, b, c) {
    return a + b + c;
}

// 柯里化版本
function curriedAdd(a) {
    return function(b) {
        return function(c) {
            return a + b + c;
        };
    };
}

console.log(add(1, 2, 3));      // 输出: 6
console.log(curriedAdd(1)(2)(3)); // 输出: 6

通用柯里化函数[编辑 | 编辑源代码]

可以编写一个通用函数，将任意多参数函数柯里化：

function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } else {
            return function(...args2) {
                return curried.apply(this, args.concat(args2));
            };
        }
    };
}

// 使用示例
const curriedSum = curry(add);
console.log(curriedSum(1)(2)(3)); // 输出: 6
console.log(curriedSum(1, 2)(3)); // 输出: 6

柯里化的优势[编辑 | 编辑源代码]

1. 延迟执行：柯里化允许逐步传递参数，直到所有参数齐全才执行函数。 2. 参数复用：可以固定部分参数，生成新的特定用途函数。 3. 函数组合：柯里化后的函数更容易与其他函数组合使用。

实际应用案例[编辑 | 编辑源代码]

日志函数[编辑 | 编辑源代码]

柯里化可以用于创建可定制的日志函数：

function log(level, message) {
    console.log(`[${level}] ${message}`);
}

const curriedLog = curry(log);
const logError = curriedLog('ERROR');
const logInfo = curriedLog('INFO');

logError('Database connection failed!'); // 输出: [ERROR] Database connection failed!
logInfo('User logged in.');            // 输出: [INFO] User logged in.

数据验证[编辑 | 编辑源代码]

柯里化可以简化数据验证逻辑：

function validate(min, max, value) {
    return value >= min && value <= max;
}

const curriedValidate = curry(validate);
const validateAge = curriedValidate(18)(100);

console.log(validateAge(25)); // true
console.log(validateAge(15)); // false

高级主题：无限柯里化[编辑 | 编辑源代码]

上述柯里化实现要求参数数量固定。对于变参函数（如 console.log），可以使用无限柯里化：

function infiniteCurry(fn) {
    return function curried(...args) {
        if (args.length === 0) {
            return fn.apply(this, args);
        }
        return function(...args2) {
            if (args2.length === 0) {
                return fn.apply(this, args);
            }
            return curried.apply(this, args.concat(args2));
        };
    };
}

const infiniteAdd = infiniteCurry((...nums) => nums.reduce((a, b) => a + b, 0));
console.log(infiniteAdd(1)(2)(3)()); // 输出: 6

性能考虑[编辑 | 编辑源代码]

柯里化会创建多个嵌套函数，可能带来一定的性能开销。在性能敏感的场景中，应权衡柯里化带来的灵活性与额外函数调用的成本。

总结[编辑 | 编辑源代码]

柯里化将多参数函数转换为单参数函数链。
提高了函数的复用性和组合性。
适用于参数复用、延迟执行和函数组合场景。
JavaScript 可以通过手动或通用函数实现柯里化。

延伸阅读[编辑 | 编辑源代码]