编辑“︁JavaScript函数柯里化”︁

= JavaScript函数柯里化 =

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

== 基本概念 ==

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

数学上，柯里化可以表示为：
<math>
f: (A \times B \times C) \rightarrow D \quad \text{转换为} \quad f: A \rightarrow (B \rightarrow (C \rightarrow D))
</math>

=== 柯里化 vs 部分应用 ===
柯里化与'''部分应用'''（Partial Application）容易混淆，但两者不同：
* '''柯里化'''：将多参数函数转换为一系列单参数函数。
* '''部分应用'''：固定一个函数的部分参数，生成一个接受剩余参数的新函数。

== JavaScript 中的柯里化实现 ==

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

<syntaxhighlight lang="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
</syntaxhighlight>

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

<syntaxhighlight lang="javascript">
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
</syntaxhighlight>

== 柯里化的优势 ==

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

== 实际应用案例 ==

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

<syntaxhighlight lang="javascript">
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.
</syntaxhighlight>

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

<syntaxhighlight lang="javascript">
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
</syntaxhighlight>

== 高级主题：无限柯里化 ==

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

<syntaxhighlight lang="javascript">
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
</syntaxhighlight>

== 性能考虑 ==

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

== 总结 ==

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

== 延伸阅读 ==

* [[函数式编程]]
* [[高阶函数]]
* [[闭包 (计算机科学)|闭包]]

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

[[Category:编程语言]]
[[Category:JavaScript]]
[[Category:Javascript函数]]