JavaScript中的函数柯里化

函数柯里化是一种将使用多个参数的函数转换成一系列使用一个参数的函数的技术。它的核心思想是：将一个多参数函数转换为多个单参数函数，也就是将一个函数分解成多个步骤，每个步骤只处理一个参数。

基本概念与原理
柯里化的名称来源于数学家Haskell Curry。在JavaScript中，柯里化函数会接收部分参数，然后返回一个新函数来处理剩余参数，直到所有参数都收集完毕才执行原函数。

实现步骤详解

1. 基础柯里化实现
   我们先看一个简单的手动柯里化示例：

// 原函数
function add(a, b, c) {
    return a + b + c;
}

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

// 使用方式
console.log(curriedAdd(1)(2)(3)); // 6

2. 通用柯里化函数实现
   下面实现一个通用的curry函数，可以柯里化任意函数：

function curry(fn) {
    return function curried(...args) {
        // 如果参数数量足够，直接执行原函数
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } 
        // 参数不足时，返回新函数继续接收剩余参数
        else {
            return function(...nextArgs) {
                return curried.apply(this, args.concat(nextArgs));
            }
        }
    }
}

// 使用示例
function multiply(a, b, c) {
    return a * b * c;
}

const curriedMultiply = curry(multiply);
console.log(curriedMultiply(2)(3)(4)); // 24
console.log(curriedMultiply(2, 3)(4)); // 24
console.log(curriedMultiply(2)(3, 4)); // 24

3. 支持占位符的高级柯里化
   更高级的实现可以支持占位符，让参数传递更灵活：

function curryWithPlaceholder(fn) {
    return function curried(...args) {
        // 过滤掉占位符，检查有效参数数量
        const validArgs = args.filter(arg => arg !== curryWithPlaceholder.placeholder);
        
        if (validArgs.length >= fn.length && args.length >= fn.length) {
            return fn.apply(this, args);
        }
        
        return function(...nextArgs) {
            // 处理占位符替换
            const combinedArgs = args.map(arg => 
                arg === curryWithPlaceholder.placeholder && nextArgs.length 
                    ? nextArgs.shift() 
                    : arg
            ).concat(nextArgs);
            
            return curried.apply(this, combinedArgs);
        }
    }
}

curryWithPlaceholder.placeholder = Symbol('placeholder');

// 使用示例
const _ = curryWithPlaceholder.placeholder;
const curriedFunc = curryWithPlaceholder(function(a, b, c, d) {
    return a + b + c + d;
});

console.log(curriedFunc(1, _, 3)(2)(4)); // 10 (1 + 2 + 3 + 4)

实际应用场景

1. 参数复用

// 创建通用的验证函数
function check(reg, text) {
    return reg.test(text);
}

// 柯里化后创建特定验证器
const curriedCheck = curry(check);
const checkPhone = curriedCheck(/^1[3456789]\d{9}$/);
const checkEmail = curriedCheck(/^\w+@\w+\.\w+$/);

console.log(checkPhone('13800138000')); // true
console.log(checkEmail('test@example.com')); // true

2. 延迟执行

// 在事件处理中的优势
const curriedLog = curry(function(level, time, message) {
    console.log(`[${level}] ${time}: ${message}`);
});

const infoLog = curriedLog('INFO', new Date().toISOString());
const errorLog = curriedLog('ERROR', new Date().toISOString());

// 在实际业务中只需要传递消息
infoLog('用户登录成功');
errorLog('数据库连接失败');

柯里化的优势与注意事项

优势：

• 参数复用，提高函数适用性
• 延迟执行，提高代码灵活性
• 函数组合更便捷

注意事项：

• 柯里化会增加函数调用层级，可能影响性能
• 不是所有场景都适合柯里化，需要根据实际情况选择
• 柯里化后的函数调用方式可能不符合传统习惯

通过理解函数柯里化的原理和实现，你可以更好地进行函数式编程，写出更加模块化和可复用的代码。