概念

只传递给函数一部分参数来调用它，让它返回一个函数去处理剩下的参数

例子 : 实现add(1)(2)(3) = 6

const add = x => y => z => x + y + z
console.log(add(1)(2)(3)) //6

解释:

函数相当于

const add = function(x) {
  return function(y) {
    return function(z) {
      return x + y + z
    }
  }
}

• add(1)：返回一个新函数 function(y) { return function(z) { return 1 + y + z } }
• add(1)(2)：返回另一个新函数 function(z) { return 1 + 2 + z }
• add(1)(2)(3)：执行最终计算 1 + 2 + 3 = 6

特点

1. 参数分步传递：每次调用只接受一个参数，返回一个新函数
2. 闭包特性：内部函数可以访问外部函数的参数（x, y）
3. 延迟执行：直到所有参数都提供后才执行最终计算

这种技术常用于函数式编程，可以提高代码的复用性和可读性

小拓展

如何支持下面这几种用法

add(1, 2, 3);
add(1, 2)(3);
add(1)(2, 3);

主要思路是 要判断当前传入函数的参数个数 (args.length) 是否大于等于原函数所需参数个数 (fn.length) ，如果是，则执行当前函数；如果是小于，则返回一个函数

函数的参数个数可以直接通过函数数的.length属性来访问!

const add = (x, y, z) => x + y + z
const curry = (fn, ...args) => {
    return args.length >= fn.length
        ? fn(...args)
        : (..._args) => curry(add, ...args, ..._args)
}
const Add = curry(add)
console.log(Add(1, 2)(3))

// 执行步骤
// Add(1, 2)(3)
// │
// ├── Add = curry(add) → 返回函数A: (...args) => curry(add, ...args)
// │
// ├── A(1, 2) → 执行 curry(add, 1, 2)
// │   ├── args = [1, 2], length=2 < 3
// │   └── 返回函数B: (...args) => curry(add, 1, 2, ...args)
// │
// └── B(3) → 执行 curry(add, 1, 2, 3)
//     ├── args = [1, 2, 3], length=3 >= 3
//     └── 执行 add(1, 2, 3) = 6