函数柯里化

什么是函数柯里化？

柯里化的核心思想是：

将一个多参数函数转换为一系列单参数函数。
每个单参数函数返回一个新的函数，等待接收下一个参数。

例如，一个接受两个参数的函数 add(a, b) 可以被柯里化为 add(a)(b)。

柯里化的优点

参数复用：
- 柯里化允许你部分应用函数，复用部分参数。
- 例如，可以创建一个预定义参数的函数，方便后续调用。
提高代码的可读性和灵活性：
- 柯里化可以使代码更具声明性，减少重复代码。
函数组合：
- 柯里化是函数式编程中的重要概念，常用于函数组合（Function Composition）。

柯里化的实现

示例 1：简单的柯里化

以下是一个简单的柯里化示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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

// 柯里化后的函数
function curryAdd(a) {
  return function(b) {
    return a + b;
  };
}

// 使用柯里化函数
const add5 = curryAdd(5); // 返回一个新函数，等待接收下一个参数
console.log(add5(3)); // 输出: 8

示例 2：通用的柯里化函数

以下是一个通用的柯里化函数实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      // 如果参数数量足够，直接调用原始函数
      return fn.apply(this, args);
    } else {
      // 如果参数数量不足，返回一个新的函数，等待接收剩余参数
      return function(...moreArgs) {
        return curried.apply(this, args.concat(moreArgs));
      };
    }
  };
}

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

// 柯里化 add 函数
const curriedAdd = curry(add);

// 使用柯里化函数
console.log(curriedAdd(1)(2)(3)); // 输出: 6
console.log(curriedAdd(1, 2)(3)); // 输出: 6
console.log(curriedAdd(1)(2, 3)); // 输出: 6
console.log(curriedAdd(1, 2, 3)); // 输出: 6

柯里化的应用场景

1. 参数复用

柯里化可以让你创建一个预定义参数的函数，方便后续调用。

1
2
3
4
5
6


function multiply(a, b) {
  return a * b;
}

const double = curry(multiply)(2); // 预定义参数 a = 2
console.log(double(5)); // 输出: 10

2. 函数组合

柯里化是函数组合的基础，可以将多个函数组合成一个新的函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


function add(a, b) {
  return a + b;
}

function multiply(a, b) {
  return a * b;
}

const addAndMultiply = curry(multiply)(curry(add)(2));
console.log(addAndMultiply(3)); // 输出: 10 (2 + 3) * 2

3. 延迟执行

柯里化可以延迟函数的执行，直到所有参数都准备好。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


function log(date, importance, message) {
  console.log(`[${date.toISOString()}] [${importance}] ${message}`);
}

const curriedLog = curry(log);

// 创建一个预定义日期和重要性的日志函数
const logNow = curriedLog(new Date(), "INFO");

// 延迟执行日志
logNow("This is a test message.");

柯里化的局限性

性能开销：
- 柯里化会增加函数的调用栈深度，可能导致性能开销。
可读性问题：
- 对于不熟悉柯里化的开发者，柯里化后的代码可能难以理解。
适用场景有限：
- 柯里化更适合函数式编程风格，对于命令式编程风格的代码，可能并不适用。

总结

函数柯里化是一种将多参数函数转换为一系列单参数函数的技术，具有以下优点：

参数复用：可以创建预定义参数的函数，方便后续调用。
提高代码的可读性和灵活性：使代码更具声明性，减少重复代码。
函数组合：是函数式编程中的重要概念，常用于函数组合。

然而，柯里化也有一些局限性，如性能开销和可读性问题。在实际开发中，应根据具体场景选择是否使用柯里化。

附录

如何理解“可以创建预定义参数的函数，方便后续调用”

“可以创建预定义参数的函数，方便后续调用” 是柯里化的一个重要特性。它的核心思想是：通过部分应用（Partial Application）参数，生成一个新的函数，这个新函数已经预定义了部分参数，等待接收剩余的参数。

什么是“预定义参数的函数”？

“预定义参数的函数”是指一个函数已经固定了部分参数，但仍然可以接收剩余的参数。通过这种方式，可以创建一个更具体的函数，方便后续调用。

例如：

原始函数：add(a, b) 需要两个参数 a 和 b。
预定义参数的函数：add5 = add(5)，这个函数已经预定义了 a = 5，只需要传入 b 即可。

示例：创建预定义参数的函数

示例 1：简单的预定义参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

// 创建一个预定义参数的函数
const add5 = (b) => add(5, b);

// 使用预定义参数的函数
console.log(add5(3)); // 输出: 8

在这个例子中，add5 是一个预定义了 a = 5 的函数，只需要传入 b 即可完成计算。

示例 2：使用柯里化创建预定义参数的函数

通过柯里化，可以更方便地创建预定义参数的函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


// 柯里化函数
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...moreArgs) {
        return curried.apply(this, args.concat(moreArgs));
      };
    }
  };
}

// 原始函数
function multiply(a, b, c) {
  return a * b * c;
}

// 柯里化 multiply 函数
const curriedMultiply = curry(multiply);

// 创建预定义参数的函数
const multiplyBy2 = curriedMultiply(2); // 预定义 a = 2
const multiplyBy2And3 = multiplyBy2(3); // 预定义 b = 3

// 使用预定义参数的函数
console.log(multiplyBy2And3(4)); // 输出: 24 (2 * 3 * 4)

在这个例子中：

curriedMultiply(2) 返回一个新函数，预定义了 a = 2。
multiplyBy2(3) 返回一个新函数，预定义了 b = 3。
multiplyBy2And3(4) 最终计算 2 * 3 * 4。

为什么“预定义参数的函数”方便后续调用？

1. 减少重复代码

通过预定义参数，可以避免在每次调用时重复传入相同的参数。

例如，假设你需要多次调用一个函数，且每次都需要传入相同的参数：

1
2
3
4
5
6
7


function log(date, importance, message) {
  console.log(`[${date.toISOString()}] [${importance}] ${message}`);
}

// 每次调用都需要传入相同的日期和重要性
log(new Date(), "INFO", "This is a test message.");
log(new Date(), "INFO", "Another message.");

通过预定义参数，可以简化调用：

1
2
3
4
5


const logNow = (message) => log(new Date(), "INFO", message);

// 只需要传入 message
logNow("This is a test message.");
logNow("Another message.");

2. 提高代码的可读性

预定义参数的函数可以使代码更具声明性，更易于理解。

例如，假设你需要计算多个数的乘积：

1
2
3
4
5
6


function multiply(a, b, c, d) {
  return a * b * c * d;
}

// 调用时需要传入所有参数
console.log(multiply(2, 3, 4, 5)); // 输出: 120

通过预定义参数，可以更清晰地表达意图：

1
2
3
4
5
6


const multiplyBy2 = (b, c, d) => multiply(2, b, c, d);
const multiplyBy2And3 = (c, d) => multiplyBy2(3, c, d);
const multiplyBy2And3And4 = (d) => multiplyBy2And3(4, d);

// 只需要传入最后一个参数
console.log(multiplyBy2And3And4(5)); // 输出: 120

3. 延迟执行

预定义参数的函数可以延迟执行，直到所有参数都准备好。

例如，假设你需要在某个条件满足时才执行函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


function sendRequest(url, data) {
  console.log(`Sending request to ${url} with data: ${data}`);
}

// 预定义 url
const sendToAPI = (data) => sendRequest("https://api.example.com", data);

// 延迟执行，直到 data 准备好
const data = { name: "John", age: 30 };
sendToAPI(data);

总结

“可以创建预定义参数的函数，方便后续调用” 是柯里化的一个重要特性，它通过部分应用参数生成一个新的函数，具有以下优点：

减少重复代码：避免在每次调用时重复传入相同的参数。
提高代码的可读性：使代码更具声明性，更易于理解。
延迟执行：可以延迟函数的执行，直到所有参数都准备好。

在实际开发中，预定义参数的函数可以显著简化代码，提升开发效率和代码质量。