定义

维基百科中对柯里化 (Currying) 的定义为：

In mathematics and computer science, currying is the technique of translating the evaluation of a function that takes multiple arguments (or a tuple of arguments) into evaluating a sequence of functions, each with a single argument.

翻译成中文：

在数学和计算机科学中，柯里化是一种将使用多个参数的一个函数转换成一系列使用一个参数的函数的技术。

举个例子：

  1. function add(a, b) {
  2.     return a + b;
  3. }
  4.  
  5. // 执行 add 函数，一次传入两个参数即可
  6. add(1, 2) // 3
  7.  
  8. // 假设有一个 curry 函数可以做到柯里化
  9. var addCurry = curry(add);
  10. addCurry(1)(2) // 3

用途

我们会讲到如何写出这个 curry 函数，并且会将这个 curry 函数写的很强大，但是在编写之前，我们需要知道柯里化到底有什么用？

举个例子：

  1. // 示意而已
  2. function ajax(type, url, data) {
  3.     var xhr = new XMLHttpRequest();
  4.     xhr.open(type, url, true);
  5.     xhr.send(data);
  6. }
  7.  
  8. // 虽然 ajax 这个函数非常通用，但在重复调用的时候参数冗余
  9. ajax('POST', 'www.test.com', "name=kevin")
  10. ajax('POST', 'www.test2.com', "name=kevin")
  11. ajax('POST', 'www.test3.com', "name=kevin")
  12.  
  13. // 利用 curry
  14. var ajaxCurry = curry(ajax);
  15.  
  16. // 以 POST 类型请求数据
  17. var post = ajaxCurry('POST');
  18. post('www.test.com', "name=kevin");
  19.  
  20. // 以 POST 类型请求来自于 www.test.com 的数据
  21. var postFromTest = post('www.test.com');
  22. postFromTest("name=kevin");

想想 jQuery 虽然有 $.ajax 这样通用的方法，但是也有 $.get 和 $.post 的语法糖。(当然 jQuery 底层是否是这样做的，我就没有研究了)。

curry 的这种用途可以理解为：参数复用。本质上是降低通用性，提高适用性。

可是即便如此，是不是依然感觉没什么用呢？

如果我们仅仅是把参数一个一个传进去，意义可能不大，但是如果我们是把柯里化后的函数传给其他函数比如 map 呢？

举个例子：

比如我们有这样一段数据：

  1. var person = [{name: 'kevin'}, {name: 'daisy'}]

如果我们要获取所有的 name 值，我们可以这样做：

  1. var name = person.map(function (item) {
  2.     return item.name;
  3. })

不过如果我们有 curry 函数：

  1. var prop = curry(function (key, obj) {
  2.     return obj[key]
  3. });
  4.  
  5. var name = person.map(prop('name'))

我们为了获取 name 属性还要再编写一个 prop 函数，是不是又麻烦了些？

但是要注意，prop 函数编写一次后，以后可以多次使用，实际上代码从原本的三行精简成了一行，而且你看代码是不是更加易懂了？

person.map(prop('name')) 就好像直白的告诉你：person 对象遍历(map)获取(prop) name 属性。

是不是感觉有点意思了呢？

第一版

未来我们会接触到更多有关柯里化的应用，不过那是未来的事情了，现在我们该编写这个 curry 函数了。

一个经常会看到的 curry 函数的实现为：

  1. // 第一版
  2. var curry = function (fn) {
  3.     var args = [].slice.call(arguments, 1);
  4.     return function() {
  5.         var newArgs = args.concat([].slice.call(arguments));
  6.         return fn.apply(this, newArgs);
  7.     };
  8. };

我们可以这样使用：

  1. function add(a, b) {
  2.     return a + b;
  3. }
  4.  
  5. var addCurry = curry(add, 1, 2);
  6. addCurry() // 3
  7. //或者
  8. var addCurry = curry(add, 1);
  9. addCurry(2) // 3
  10. //或者
  11. var addCurry = curry(add);
  12. addCurry(1, 2) // 3

已经有柯里化的感觉了，但是还没有达到要求，不过我们可以把这个函数用作辅助函数，帮助我们写真正的 curry 函数。

第二版

  1. // 第二版
  2. function sub_curry(fn) {
  3.     var args = [].slice.call(arguments, 1);
  4.     return function() {
  5.         return fn.apply(this, args.concat([].slice.call(arguments)));
  6.     };
  7. }
  8.  
  9. function curry(fn, length) {
  10.  
  11.     length = length || fn.length;
  12.  
  13.     var slice = Array.prototype.slice;
  14.  
  15.     return function() {
  16.         if (arguments.length < length) {
  17.             var combined = [fn].concat(slice.call(arguments));
  18.             return curry(sub_curry.apply(this, combined), length - arguments.length);
  19.         } else {
  20.             return fn.apply(this, arguments);
  21.         }
  22.     };
  23. }

我们验证下这个函数：

  1. var fn = curry(function(a, b, c) {
  2.     return [a, b, c];
  3. });
  4.  
  5. fn("a", "b", "c") // ["a", "b", "c"]
  6. fn("a", "b")("c") // ["a", "b", "c"]
  7. fn("a")("b")("c") // ["a", "b", "c"]
  8. fn("a")("b", "c") // ["a", "b", "c"]

效果已经达到我们的预期，然而这个 curry 函数的实现好难理解呐……

为了让大家更好的理解这个 curry 函数，我给大家写个极简版的代码：

  1. function sub_curry(fn){
  2.     return function(){
  3.         return fn()
  4.     }
  5. }
  6.  
  7. function curry(fn, length){
  8.     length = length || 4;
  9.     return function(){
  10.         if (length > 1) {
  11.             return curry(sub_curry(fn), --length)
  12.         }
  13.         else {
  14.             return fn()
  15.         }
  16.     }
  17. }
  18.  
  19. var fn0 = function(){
  20.     console.log(1)
  21. }
  22.  
  23. var fn1 = curry(fn0)
  24.  
  25. fn1()()()() // 1

大家先从理解这个 curry 函数开始。

当执行 fn1() 时，函数返回：

  1. curry(sub_curry(fn0))
  2. // 相当于
  3. curry(function(){
  4.     return fn0()
  5. })

当执行 fn1()() 时，函数返回：

  1. curry(sub_curry(function(){
  2.     return fn0()
  3. }))
  4. // 相当于
  5. curry(function(){
  6.     return (function(){
  7.         return fn0()
  8.     })()
  9. })
  10. // 相当于
  11. curry(function(){
  12.     return fn0()
  13. })

当执行 fn1()()() 时，函数返回：

  1. // 跟 fn1()() 的分析过程一样
  2. curry(function(){
  3.     return fn0()
  4. })

当执行 fn1()()()() 时，因为此时 length > 2 为 false，所以执行 fn()：

  1. fn()
  2. // 相当于
  3. (function(){
  4.     return fn0()
  5. })()
  6. // 相当于
  7. fn0()
  8. // 执行 fn0 函数，打印 1

再回到真正的 curry 函数，我们以下面的例子为例：

  1. var fn0 = function(a, b, c, d) {
  2.     return [a, b, c, d];
  3. }
  4.  
  5. var fn1 = curry(fn0);
  6.  
  7. fn1("a", "b")("c")("d")

当执行 fn1("a", "b") 时：

  1. fn1("a", "b")
  2. // 相当于
  3. curry(fn0)("a", "b")
  4. // 相当于
  5. curry(sub_curry(fn0, "a", "b"))
  6. // 相当于
  7. // 注意 ... 只是一个示意，表示该函数执行时传入的参数会作为 fn0 后面的参数传入
  8. curry(function(...){
  9.     return fn0("a", "b", ...)
  10. })

当执行 fn1("a", "b")("c") 时，函数返回：

  1. curry(sub_curry(function(...){
  2.     return fn0("a", "b", ...)
  3. }), "c")
  4. // 相当于
  5. curry(function(...){
  6.     return (function(...) {return fn0("a", "b", ...)})("c")
  7. })
  8. // 相当于
  9. curry(function(...){
  10.      return fn0("a", "b", "c", ...)
  11. })

当执行 fn1("a", "b")("c")("d") 时，此时 arguments.length < length 为 false ，执行 fn(arguments)，相当于：

  1. (function(...){
  2.     return fn0("a", "b", "c", ...)
  3. })("d")
  4. // 相当于
  5. fn0("a", "b", "c", "d")

函数执行结束。

所以，其实整段代码又很好理解：

sub_curry 的作用就是用函数包裹原函数，然后给原函数传入之前的参数，当执行 fn0(…)(…) 的时候，执行包裹函数，返回原函数，然后再调用 sub_curry 再包裹原函数，然后将新的参数混合旧的参数再传入原函数，直到函数参数的数目达到要求为止。

如果要明白 curry 函数的运行原理，大家还是要动手写一遍，尝试着分析执行步骤。

更易懂的实现

当然了，如果你觉得还是无法理解，你可以选择下面这种实现方式，可以实现同样的效果：

  1. function curry(fn, args) {
  2.     var length = fn.length;
  3.  
  4.     args = args || [];
  5.  
  6.     return function() {
  7.  
  8.         var _args = args.slice(0),
  9.  
  10.             arg, i;
  11.  
  12.         for (i = 0; i < arguments.length; i++) {
  13.  
  14.             arg = arguments[i];
  15.  
  16.             _args.push(arg);
  17.  
  18.         }
  19.         if (_args.length < length) {
  20.             return curry.call(this, fn, _args);
  21.         }
  22.         else {
  23.             return fn.apply(this, _args);
  24.         }
  25.     }
  26. }
  27.  
  28.  
  29. var fn = curry(function(a, b, c) {
  30.     console.log([a, b, c]);
  31. });
  32.  
  33. fn("a", "b", "c") // ["a", "b", "c"]
  34. fn("a", "b")("c") // ["a", "b", "c"]
  35. fn("a")("b")("c") // ["a", "b", "c"]
  36. fn("a")("b", "c") // ["a", "b", "c"]

或许大家觉得这种方式更好理解，又能实现一样的效果，为什么不直接就讲这种呢？

因为想给大家介绍各种实现的方法嘛，不能因为难以理解就不给大家介绍呐~

第三版

curry 函数写到这里其实已经很完善了，但是注意这个函数的传参顺序必须是从左到右，根据形参的顺序依次传入，如果我不想根据这个顺序传呢？

我们可以创建一个占位符，比如这样：

  1. var fn = curry(function(a, b, c) {
  2.     console.log([a, b, c]);
  3. });
  4.  
  5. fn("a", _, "c")("b") // ["a", "b", "c"]

我们直接看第三版的代码：

  1. // 第三版
  2. function curry(fn, args, holes) {
  3.     length = fn.length;
  4.  
  5.     args = args || [];
  6.  
  7.     holes = holes || [];
  8.  
  9.     return function() {
  10.  
  11.         var _args = args.slice(0),
  12.             _holes = holes.slice(0),
  13.             argsLen = args.length,
  14.             holesLen = holes.length,
  15.             arg, i, index = 0;
  16.  
  17.         for (i = 0; i < arguments.length; i++) {
  18.             arg = arguments[i];
  19.             // 处理类似 fn(1, _, _, 4)(_, 3) 这种情况，index 需要指向 holes 正确的下标
  20.             if (arg === _ && holesLen) {
  21.                 index++
  22.                 if (index > holesLen) {
  23.                     _args.push(arg);
  24.                     _holes.push(argsLen - 1 + index - holesLen)
  25.                 }
  26.             }
  27.             // 处理类似 fn(1)(_) 这种情况
  28.             else if (arg === _) {
  29.                 _args.push(arg);
  30.                 _holes.push(argsLen + i);
  31.             }
  32.             // 处理类似 fn(_, 2)(1) 这种情况
  33.             else if (holesLen) {
  34.                 // fn(_, 2)(_, 3)
  35.                 if (index >= holesLen) {
  36.                     _args.push(arg);
  37.                 }
  38.                 // fn(_, 2)(1) 用参数 1 替换占位符
  39.                 else {
  40.                     _args.splice(_holes[index], 1, arg);
  41.                     _holes.splice(index, 1)
  42.                 }
  43.             }
  44.             else {
  45.                 _args.push(arg);
  46.             }
  47.  
  48.         }
  49.         if (_holes.length || _args.length < length) {
  50.             return curry.call(this, fn, _args, _holes);
  51.         }
  52.         else {
  53.             return fn.apply(this, _args);
  54.         }
  55.     }
  56. }
  57.  
  58. var _ = {};
  59.  
  60. var fn = curry(function(a, b, c, d, e) {
  61.     console.log([a, b, c, d, e]);
  62. });
  63.  
  64. // 验证 输出全部都是 [1, 2, 3, 4, 5]
  65. fn(1, 2, 3, 4, 5);
  66. fn(_, 2, 3, 4, 5)(1);
  67. fn(1, _, 3, 4, 5)(2);
  68. fn(1, _, 3)(_, 4)(2)(5);
  69. fn(1, _, _, 4)(_, 3)(2)(5);
  70. fn(_, 2)(_, _, 4)(1)(3)(5)

写在最后

至此，我们已经实现了一个强大的 curry 函数，可是这个 curry 函数符合柯里化的定义吗？柯里化可是将一个多参数的函数转换成多个单参数的函数，但是现在我们不仅可以传入一个参数，还可以一次传入两个参数，甚至更多参数……这看起来更像一个柯里化 (curry) 和偏函数 (partial application) 的综合应用，可是什么又是偏函数呢？下篇文章会讲到。

专题系列

JavaScript专题系列目录地址：https://github.com/mqyqingfeng/Blog。

JavaScript专题系列预计写二十篇左右，主要研究日常开发中一些功能点的实现，比如防抖、节流、去重、类型判断、拷贝、最值、扁平、柯里、递归、乱序、排序等，特点是研(chao)究(xi) underscore 和 jQuery 的实现方式。

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。