高级柯里化实现

一、柯里化（Currying）是一种关于函数的高阶技术。它不仅被用于 JavaScript，还被用于其他编程语言。
二、柯里化是一种函数的转换，它是指将一个函数从可调用的f(a, b, c)转换为可调用的f(a)(b)(c)。
1、JavaScript 实现通常都保持该函数可以被正常调用，并且如果参数数量不足，则返回偏函数。
三、柯里化不会调用函数。它只是对函数进行转换。
三、让我们先来看一个例子，以更好地理解我们正在讲的内容，然后再进行一个实际应用。
1、我们将创建一个辅助函数curry(f)，该函数将对两个参数的函数f执行柯里化。换句话说，对于两个参数的函数f(a, b)执行curry(f)会将其转换为以f(a)(b)形式运行的函数：

function curry(f) { // curry(f) 执行柯里化转换
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}
// 用法
function sum(a, b) {
  return a + b;
}
let curriedSum = curry(sum);
alert(curriedSum);
/**得到的结果如下：
function(a) {
    return function(b) {
      return f(a,b)
  }
}
*/
alert( curriedSum(1) );
/**得到的结果如下：
function(b) {
    return f(a, b);
}
*/
alert( curriedSum(1)(2) ); // 3

2、正如你所看到的，实现非常简单：只有两个包装器（wrapper）。

curry(func)的结果就是一个包装器function(a)。
当它被像curriedSum(1)这样调用时，它的参数会被保存在词法环境中，然后返回一个新的包装器function(b)。
然后这个包装器被以2为参数调用，并且，它将该调用传递给原始的sum函数。

3、柯里化更高级的实现，例如 lodash 库的_.curry，会返回一个包装器，该包装器允许函数被正常调用或者以偏函数（partial）的方式调用：

function sum(a, b) {
  return a + b;
}
let curriedSum = _.curry(sum); // 使用来自 lodash 库的 _.curry
alert( curriedSum(1, 2) ); // 3，仍可正常调用
alert( curriedSum(1)(2) ); // 3，以偏函数的方式调用

一、柯里化：收集参数，延后执行，也可以称之为部分求值

| 【示例】``` function add(a, b) { return a + b }

// 简单的通用封装 function curry(fn) { let args = Array.prototype.slice.call(arguments, 1) return function() { let _args = Array.prototype.slice.call(arguments) let final = args.concat(_args) return fn.apply(null, final) } }

// 对函数 add 柯里化 let adder = curry(add) adder(1, 2) // 或者 let adder = curry(add, 1)(2) let adder = curry(add)(1, 2)

 |
| --- |
| 【示例】一个典型的通用型 curry 封装

Function.prototype.mybind = function(fn) { let args = Array.prototype.slice(arguments, 1) let _this = this return function() { let _args = Array.prototype.slice(arguments) let final = args.concat(_args) return _this.apply(fn, final) } }

 |
| --- |

| 【示例】通过 curry 函数的这种模式，我们就能实现一个简单的 bind

 |
| --- |

| 【示例】函数柯里化也是我们在面试过程中可能会经常碰到的问题，比如：

// 编写一个 add 函数，实现以下功能 add(1)(2)(3) // 6 add(1)(2, 3)(4) //10 add(1, 2)(3) (4, 5) // 15

function add() { let args = Array.prototype.slice.call(arguments) let adder = function() { // 利用闭包的特性保存 args 并且收集参数 args = args.concat(Array.prototype.slice.call(arguments)) return adder } // 利用 toString 隐式转换的的特性返回最终计算的值 adder.toString = function() { return args.reduce((a, b) => { return a + b }) } return adder } add(1)(2)(3) // 6 add(1)(2, 3)(4) // 10 add(1, 2)(3)(4, 5) // 15

// 当然，我们也可以借助ES6的方法简化这个函数 function add1(…args) { let adder = (…_args) => { args = […args, …_args] return adder } adder.toString = () => args.reduce((a, b) => a + b) return adder }

1、想要实现上面函数的效果，有两点是我们必须理解和掌握的：<br />- 闭包，使用闭包的特性去保存和收集我们需要的参数<br />- 利用 toString 的隐式转换特性，最终拿到我们想要的结果<br /> |
| --- |

<a name="U9sVB"></a>
# 柯里化？目的是什么？
一、要了解它的好处，我们需要一个实际中的例子。<br />二、例如，我们有一个用于格式化和输出信息的日志（logging）函数log(date, importance, message)。在实际项目中，此类函数具有很多有用的功能，例如通过网络发送日志（log），在这儿我们仅使用alert：
```javascript
function log(date, importance, message) {
  alert(`[${date.getHours()}:${date.getMinutes()}] [${importance}] ${message}`);
}

1、让我们将它柯里化！

log = _.curry(log);

2、柯里化之后，log仍正常运行：

log(new Date(), "DEBUG", "some debug"); // log(a, b, c)

3、但是也可以以柯里化形式运行：

log(new Date())("DEBUG")("some debug"); // log(a)(b)(c)

4、现在，我们可以轻松地为当前日志创建便捷函数：

// logNow 会是带有固定第一个参数的日志的偏函数
let logNow = log(new Date());

// 使用它
logNow("INFO", "message"); // [HH:mm] INFO message

5、现在，logNow是具有固定第一个参数的log，换句话说，就是更简短的“偏应用函数（partially applied function）”或“偏函数（partial）”。
6、我们可以更进一步，为当前的调试日志（debug log）提供便捷函数：

let debugNow = logNow("DEBUG");

debugNow("message"); // [HH:mm] DEBUG message

三、1、柯里化之后，我们没有丢失任何东西：log依然可以被正常调用。
2、我们可以轻松地生成偏函数，例如用于生成今天的日志的偏函数。

高级柯里化实现

一、如果你想了解更多细节，下面是用于多参数函数的“高级”柯里化实现，我们也可以把它用于上面的示例。
1、它非常短：

function curry(func) {

  return function curried(...args) {
    if (args.length >= func.length) {
      return func.apply(this, args);
    } else {
      return function(...args2) {
        return curried.apply(this, args.concat(args2));
      }
    }
  };

}

2、用例：

function sum(a, b, c) {
  return a + b + c;
}

let curriedSum = curry(sum);

alert( curriedSum(1, 2, 3) ); // 6，仍然可以被正常调用
alert( curriedSum(1)(2,3) ); // 6，对第一个参数的柯里化
alert( curriedSum(1)(2)(3) ); // 6，全柯里化

3、新的curry可能看上去有点复杂，但是它很容易理解。
4、curry(func)调用的结果是如下所示的包装器curried：

// func 是要转换的函数
function curried(...args) {
  if (args.length >= func.length) { // (1)
    return func.apply(this, args);
  } else {
    return function pass(...args2) { // (2)
      return curried.apply(this, args.concat(args2));
    }
  }
};

5、当我们运行它时，这里有两个if执行分支：
（1）现在调用：如果传入的args长度与原始函数所定义的（func.length）相同或者更长，那么只需要将调用传递给它即可。
（2）获取一个偏函数：否则，func还没有被调用。取而代之的是，返回另一个包装器pass，它将重新应用curried，将之前传入的参数与新的参数一起传入。然后，在一个新的调用中，再次，我们将获得一个新的偏函数（如果参数不足的话），或者最终的结果。
6、例如，让我们看看sum(a, b, c)这个例子。它有三个参数，所以sum.length = 3。
7、对于调用curried(1)(2)(3)：
（1）第一个调用curried(1)将1保存在词法环境中，然后返回一个包装器pass。
（2）包装器pass被调用，参数为(2)：它会获取之前的参数(1)，将它与得到的(2)连在一起，并一起调用curried(1, 2)。由于参数数量仍小于 3，curry函数依然会返回pass。
（3）包装器pass再次被调用，参数为(3)，在接下来的调用中，pass(3)会获取之前的参数 (1,2) 并将3与之合并，执行调用curried(1, 2, 3)— 最终有3个参数，它们被传入最原始的函数中。
一、柯里化要求函数具有固定数量的参数。
1、使用 rest 参数的函数，例如f(…args)，不能以这种方式进行柯里化。
二、根据定义，柯里化应该将sum(a, b, c)转换为sum(a)(b)(c)。
1、但是，如前所述，JavaScript 中大多数的柯里化实现都是高级版的：它们使得函数可以被多参数变体调用。

😈 JavaScript大魔王

【见】柯里化（Currying）

高级柯里化实现