const list = [0, 1, 2, 3];
list.map(elem => elem + 1);

const list = [0, 1, 2, 3];
list.map(elem => elem + 1);
list.map(elem => elem + 2);

// plus返回部分配置好的函数
const plus1 = plus(1);
const plus2 = plus(2);
plus1(5); // => 6
plus2(7); // => 9

const list = [0, 1, 2, 3];
list.map(plus1); // => [1, 2, 3, 4]
list.map(plus2); // => [2, 3, 4, 5]

// 原始的加法函数
function origPlus(a, b) {
 return a + b;
}
// 柯里化后的plus函数
function plus(a) {
 return function(b) {
  return a + b;
 }
}
// ES6写法
const plus = a => b => a + b;

multiPlus(1)(2)(3); // => 6

// ES5
function curry(fn) {
 function _c(restNum, argsList) {
  return restNum === 0 "htmlcode">

function(x) {
 return _c(restNum - 1, argsList.concat(x));
}


来继续接收参数。这里形成了一个尾递归，函数接受了一个参数后，剩余需要参数数量 restNum 减一，并将新参数 x 加入 argsList 后传入 _c 进行递归调用。结果就是，当参数数量不足时，返回负责接收新参数的单参数函数，当参数够了时，就调用原函数并返回。
现在再来看：


function curry(fn) {
 function _c(restNum, argsList) {
  return restNum === 0 "htmlcode">

// ES6
const curry = fn => {
 const _c = (restNum, argsList) => restNum === 0 "htmlcode">

function curry(fn) {
 const len = fn.length;
 return function judge(...args1) {
  return args1.length >= len "htmlcode">

console.time("curry");
const plus = curry((a, b, c, d, e) => a + b + c + d + e);
plus(1)(2)(3)(4)(5);
console.timeEnd("curry");


在我的电脑（Manjaro Linux，Intel Xeon E5 2665，32GB DDR3 四通道1333Mhz，Node.js 9.2.0）上：
本篇提到的方法耗时约 0.325ms


其他方法的耗时约 0.345ms


差的这一点猜测是闭包的原因。由于闭包的访问比较耗性能，而这种方式形成了两个闭包：fn 和 len，前面提到的方法只形成了 fn 一个闭包，所以造成了这一微小的差距。

                                
                                

                                    JS,自动柯里化 
                                

                                    标签：
                                        
JS,自动柯里化
                                     

                                
极乐门资源网 Design By www.ioogu.com