不过多介绍柯里化的定义和应用场景，直接看实现。

柯里化实现

如果我们有以下加法函数：

1
const add = (a, b) => a + b

要怎么实现柯里化呢？

手工柯里化

我们可以选择直接手写柯里化的 add：

1
// 手工柯里化
2
const curryingAdd = a => b => a + b
3

4
// 使用
5
const inc = curryingAdd(1)
6
inc(1) // 2

通过闭包的嵌套，我们可以实现每次只接受一个参数的手工柯里化的函数。

但是这种方式，对于每个需要柯里化的函数，都需要侵入其实现，非常麻烦。因此并没有什么实用价值。我们需要能一种通用的方案来自动化做这个事情。

自动柯里化

柯里化的实现，核心在于根据参数数量选择返回接受剩余参数的新函数，或者返回最终结果。

在 JavaScript 中，具备实现这一切的条件，我们可以通过函数的 length 得知形参的数量，通过 arguments 对象得知实参的信息，通过闭包返回新函数也不在话下。下面开始尝试实现，先从简单的两个参数的情况开始：

1
// 单一参数函数的柯里化
2
const curry1 = (fn) => {
3
  // 生成一个柯里化的版本
4
  return function currying(a) {
5
    // 检查实参数量
6
    // 此处不能简单地用 undefined 判断，
7
    // 因为 fn 本身可能也能接受并处理 undefined
8
    switch (arguments.length) {
9
      // 没有传入任何参数，返回柯里化后的函数本身
10
      case 0: return currying
11

12
      // 传入了任意大于 0 个数量的参数，则调用应用它们
13
      default: return fn.apply(void 0, arguments)
14
    }
15
  }
16
}
17

18
// 两个参数的函数柯里化
19
const curry2 = (fn) => {
20
  // 生成一个柯里化的版本
21
  return function currying(a,b) {
22
    // 同 curry1，检查实参数量
23
    switch (arguments.length) {
24
      // 没有传入任何参数，返回柯里化后的函数本身
25
      case 0: return currying
26

27
      // 传入了 1 个参数，则记录下该参数，
28
      // 创建一个接受剩余参数的新函数并柯里化
29
      // 相当于简化了函数的参数规模
30
      case 1: {
31
        const arg = arguments[0]
32

33
        // 自动柯里化接受剩余参数的函数
34
        // 剩余参数只有 1 个，因此使用 curry1
35
        return curry1(function() {
36
          // 合并外层函数已经部分应用的参数
37
          const args = [arg]
38
          args.push.apply(args, arguments)
39

40
          return fn.apply(void 0, args)
41
        })
42
      }
43

44
      // 传入了足够的参数时，直接应用这些参数
45
      default: return fn.apply(void 0, arguments)
46
    }
47
  }
48
}
49

50
// 使用
51
const add = (a, b) => a + b
52
const curryingAdd = curry2(add)
53
curryingAdd(1, 1) // 2
54
curryingAdd(1)(1) // 2
55
curryingAdd()(1)()(1) // 2
56
// ...

以上代码实现了通用的 2 个参数的函数的柯里化。

但如果参数的数量有很多呢，我们不可能也没必要去创建 curry3 、curry4 … curryN 等等一大批函数。完全可以定义一个通用的 curryN，指定 N ，返回自动柯里化的函数，例如下面就是一个实现：

1
// 缓存 slice
2
const slice = Array.prototype.slice
3

4
const curryN = (arity, fn) => {
5
  // 返回柯里化的版本
6
  return function currying() {
7
    // 本次调用的实参个数
8
    const consumedCount = arguments.length
9

10
    // 传入 0 个参数，返回柯里化后的函数本身
11
    if (consumedCount === 0) return currying
12

13
    // 算出剩余参数数量
14
    const rest = arity - consumedCount
15

16
    // 如果剩余参数不大于零，意味着提供的实参已经足够了，
17
    // 可以正式计算并返回结果了
18
    if (rest <= 0) {
19
      return fn.apply(void 0, arguments)
20
    }
21

22
    // 如果提供的实参，只是部分应用，则记录下它们
23
    // 后续用于合并参数
24
    const consumedArgs = slice.call(arguments)
25

26
    // 检查剩余参数数量，进行不同的递归处理
27
    switch (rest) {
28
      // 快速路径，如果只有一个参数，curry1 处理剩余参数
29
      case 1:
30
        return curry1(function(a) {
31
          // 合并外层函数的实参
32
          consumedArgs.push.apply(consumedArgs, arguments)
33
          return fn.apply(void 0, consumedArgs)
34
        })
35

36
      // 快速路径，同上
37
      case 2:
38
        return curry2(function(a, b) {
39
          consumedArgs.push.apply(consumedArgs, arguments)
40
          return fn.apply(void 0, consumedArgs)
41
        })
42

43
      // 剩余参数更多，则递归 curryN 处理剩余参数
44
      default: {
45
        return curryN(rest, function() {
46
          consumedArgs.push.apply(consumedArgs, arguments)
47
          return fn.apply(void 0, consumedArgs)
48
        })
49
      }
50
    }
51
  }
52
}
53

54
// 使用：
55

56
const add = (a, b) => a + b
57
curryN(2, add)(1, 1) // 2
58
curryN(2, add)(1)(1) // 2

以上就是通用 curryN 的实现代码，只要传入了正确的元数，就可以柯里化任何参数数量的函数了。

有了上面的实现代码后，我们就可以提供一个简单的 curry 函数作为对外的 API 了

1
const curry = (fn, arity) => {
2
  // 如果没有指定元数，
3
  // 则通过 length 属性获取
4
  arity = arity || fn.length
5

6
  switch (arity) {
7
    case 0: return fn
8
    case 1: return curry1(fn)
9
    case 2: return curry2(fn)
10
    default: return curryN(arity, fn)
11
  }
12
}
13

14
// 使用
15

16
const add = (a, b) => a + b
17
curry(add)(1)(1) // 2

curry 可以处理所有参数都用形参定义了的函数。而默认参数、不定义形参直接处理 arguments 等情况的函数，则无法正确处理，只能使用传入第二个参数来手工提供元数。例如：

1
const add = (a, b = 10) => a + b
2
add.length // 1
3

4
curry(add)(1) // 11
5
curry(add)(1)(1) // TypeError
6

7
// 传入第二个参数指定元数
8
curry(add, 2)(1)(1) // 2

元数信息丢失

以上实现的 curry1，curry2，curryN 函数，都存在一个问题，就是生成出来的柯里化后的函数，都会丢失掉元数的信息：

1
const add = (a, b) => a + b
2

3
add.length // 2
4

5
curry(add).length // 0

这在一些需要判断参数数量的场景会导致 bug，因此，有必要对该问题进行修复。

而修复的一个可行的方法为，柯里化时候，根据元数，返回一个对应形参数量的函数，以下按照该思路进行改写：

1
const curry1 = (fn) => {
2
  // 注意此处，我们为函数提供了一个 `a` 作为形参，
3
  // 用于 “撑开” 函数的元数
4
  return function currying(a) {
5
    switch (arguments.length) {
6
      case 0: return currying
7
      default: return fn.apply(void 0, arguments)
8
    }
9
  }
10
}

同理，我们可以改写 curry2 ，使用两个形参 “撑开” 函数。但是，对于 curryN，因为元数本身是不确定数量的，我们就没办法这么处理了。这时候，我们可以设计一个辅助函数 _arity(n, fn)，专门用于生成指定数量形参的函数：

1
function _arity(n, fn) {
2
  // 对于数量比较少的情况，直接暴力枚举处理
3
  switch (n) {
4
    case 1: return function(a) {
5
      return fn.apply(void 0, arguments)
6
    }
7
    case 2: return function(a, b) {
8
      return fn.apply(void 0, arguments)
9
    }
10
    case 3: return function(a,b,c) {
11
      return fn.apply(void 0, arguments)
12
    }
13
    case 4: return function(a,b,c,d) {
14
      return fn.apply(void 0, arguments)
15
    }
16
    case 5: return function(a,b,c,d,e) {
17
      return fn.apply(void 0, arguments)
18
    }
19
    case 6: return function(a,b,c,d,e,f) {
20
      return fn.apply(void 0, arguments)
21
    }
22
    case 7: return function(a,b,c,d,e,f,g) {
23
      return fn.apply(void 0, arguments)
24
    }
25
    case 8: return function(a,b,c,d,e,f,g,h) {
26
      return fn.apply(void 0, arguments)
27
    }
28
    case 9: return function(a,b,c,d,e,f,g,h,i) {
29
      return fn.apply(void 0, arguments)
30
    }
31
    case 10: return function(a,b,c,d,e,f,g,h,i,j) {
32
      return fn.apply(void 0, arguments)
33
    }
34
    // 元数很多时，使用另一种方法
35
    default: return arityMany(n, fn)
36
  }
37
}

我们首先假设，正常的使用过程中，形参应该不会大于 10 个，各种情况，逐个简单粗暴返回一个包裹函数即可。

而对于超过 10 个形参的情况，我们无法也没必要一一枚举了，直接调用另一个辅助函数，aritiMany，实现代码如下：

1
function arityMany(n, fn) {
2
  let params = []
3
  params.push('fn')
4
  let ret = `return function(`
5
  let index = -1
6
  while (++index < n) {
7
    ret += index === 0 ? `_${index}` : `,_${index}`
8
  }
9
  ret += `){return fn.apply(void 0,arguments)}`
10
  params.push(ret)
11
  const newFn = new Function(...params)
12
  return newFn(fn)
13
}

利用了 new Function 的方式，动态生成一个指定元数的包裹函数。

有了以上辅助函数后，我们就可以改写 curryN 的实现了：

1
const curryN = (arity, fn) => {
2
  function currying() {
3
    // ...实现代码同上文
4
  }
5

6
  // 注意此处，
7
  // 使用 wrapper 包裹，以确保 length 正确
8
  const wrapper = _arity(arity, currying)
9
  // 返回包裹后的函数
10
  return wrapper
11
}
12

13
// 检查
14
const add = (a, b) => a + b
15
add.length // 2
16
curry(add).length // 2

至此，元数问题解决。

TS 类型

自动柯里化的 TS 类型写法比较绕，核心有以下部分：

1
type Cast<X, Y> = X extends Y ? X : Y
2
type Length<T extends any[]> = T['length']
3
type Drop<N extends number, T extends any[], I extends any[] = []> = {
4
  0: Drop<N, Tail<T>, Prepend<any, I>>
5
  1: T
6
}[Length<I> extends N ? 1  : 0]
7

8
type Arity1<A, R> = (a: A, ...rest: any[]) => R
9
type Arity2<A, B, R> = (a: A, b: B, ...rest: any[]) => R
10
type ArityN<P extends any[], R> = (...args:P)=>R
11

12
interface Curry1<A, R> {
13
  (): Curry1<A, R>
14
  (a: A, ...rest: any[]): R
15
}
16

17
interface Curry2<A, B, R> {
18
  (): Curry2<A, B, R>
19
  (a: A, ...rest: any[]): Curry1<B, R>
20
  (a: A, b: B, ...rest: any[]): R
21
}
22

23
type Currying<P extends any[], R> = <T extends any[]>(...args: Cast<T, Partial<P>>) =>
24
  // 没有剩余参数可消耗，则返回最终结果
25
  Drop<Length<T>, P> extends [] ? R
26
  // 剩余 1
27
  : Drop<Length<T>, P> extends [infer A] ? Curry1<A, R>
28
  // 剩余 2
29
  : Drop<Length<T>, P> extends [infer A, infer B] ? Curry2<A, B, R>
30
  // 剩余更多，走 curryN
31
  : Drop<Length<T>, P> extends [any, ...any[]] ? Currying<Drop<Length<T>, P> extends infer REST ? Cast<REST, any[]> : never, R> : never

1
function curry1<A, R>(fn: Arity1<A, R>) {
2
  // 重载
3
  function curried(): Curry1<A, R>
4
  function curried(a: A): R
5
  function curried(a: A, ...rest: any): R
6
  // 实现
7
  return function curried(a?) {/**/}
8
}
9

10
function curry2<A, B, R>(fn: Arity2<A, B, R>) {
11
  // 重载
12
  function curried(): Curry2<A, B, R>
13
  function curried(a: A): Curry1<B, R>
14
  function curried(a: A, b: B): R
15
  function curried(a: A, b: B, ...rest: any): R
16
  // 实现
17
  return function curried(a?, b?) {/**/}
18
}
19

20
function curryN<P extends any[], R>(
21
  arity: number,
22
  fn: (...args: P) => R
23
): Currying<P, R> | ArityType<P, R> {
24
  // 实现...
25
}
26

27
function curry<P extends any[], R>(fn: (() => R)): typeof fn
28
function curry<A, R>(fn: ((a: A) => R)): Curry1<A, R>
29
function curry<A, B, R>(fn: ((a: A, b: B) => R)): Curry2<A, B, R>
30
function curry<P extends any[], R>(fn: ((...args: P) => R)): Currying<P, R>
31
// 传入了 arity，则需要手动传入 P，不能使用 fn 的类型来推断，因为参数长度和手工指定的 arity 不一定一致
32
function curry<P extends any[], R>(fn: ((...args) => R), arity: number): Currying<P, R>
33
// 可以传入 arity 指定元数，
34
// 以支持默认值参数 & rest 参数（目前这么做会失去 TS 类型信息）
35
// 另外，指定元数后，参数默认值不会被使用
36
function curry(fn, arity?: number) {/**/}

完整和性能优化的 typescript 实现，等我不那么懒了，再发布到 github 上。

性能优化

由于柯里化过程中，需要创建大量的闭包，还有大量的操作 arguments 对象，因此性能会有比较大幅度的下降。有些实现中，还支持使用占位符，性能更是感人。所以作为一个基础工具函数，适当的压榨性能，还是存在意义的。

比较简单的优化方向可以有：

枚举处理常见的参数长度，而不是简单粗暴地 apply arguments，
参数拼接方法的选择，例如 push，concat，ES6 的 ... 运算符等等
根据需要处理的函数参数数量，提供 curry1, curry2, curry3 等快捷方式
…

不过许多优化都针对引擎的实现，会随着引擎的发展变化，所以是否优化也需要权衡取舍。

全文完

JavaScript 中的柯里化