JavaScript函数柯里化

JavaScript函数柯里化

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

基本概念

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

数学上，柯里化可以表示为： $f:(A\times B\times C)\to D\text{转换为}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 可以通过手动或通用函数实现柯里化。

延伸阅读

• 函数式编程
• 高阶函数
• 闭包

graph LR A[多参数函数] --> B[柯里化] B --> C[单参数函数链] C --> D[延迟执行] C --> E[参数复用] C --> F[函数组合]