理解JS里的偏函数与柯里化

　　联系到上篇博客讲的bind完整的语法为：

let bound = func.bind(context, arg1, arg2, ...);

　　能够绑定上下文this和函数的初始参数。举例，咱们有个乘法函数mul(a,b)：

function mul(a, b) { return a * b; }

　　咱们能够在该函数的基础上使用绑定建立一个double函数：

let double = mul.bind(null, 2); alert( double(3) ); // = mul(2, 3) = 6

　　调用mul.bind(null, 2)建立新函数double，传递调用mul函数，固定第一个参数上下文为null，第二个参数为2，多个参数传递也是如此。

　　这称为偏函数应用——咱们创造一个新函数，让现有的一些参数值固定。

　　注意，这里确实不用this，但bind须要，因此必须使用null。

　　为何咱们一般使用偏函数？

　　这里咱们偏函数的好处是：

　　（1）经过建立一个名称易懂的独立函数（double，triple等），调用时无需每次传入第一个参数，由于第一个参数经过bind提供了固定值。

　　（2）另外一种使用偏函数状况是，当咱们有一个很通用的函数，为了方便提供一个较经常使用的变体。举例，咱们有一个函数send(from, to, text)，那么使用偏函数能够建立一个从当前用户发送的变体：sendTo(to, text)

偏函数与柯里化定义：

　　维基百科中对偏函数 (Partial application) 的定义为：

In computer science, partial application (or partial function application) 
refers to the process of fixing a number of arguments to a function, 
producing another function of smaller arity.

　　翻译成中文：在计算机科学中，局部应用是指固定一个函数的一些参数，而后产生另外一个更小元的函数。（什么是元？元是指函数参数的个数，好比一个带有两个参数的函数被称为二元函数。）

　　维基百科中对柯里化 (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.

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

　　偏函数与柯里化区别：

　　柯里化是将一个多参数函数转换成多个单参数函数，也就是将一个 n 元函数转换成 n 个一元函数。

　　局部应用则是固定一个函数的一个或者多个参数，也就是将一个 n 元函数转换成一个 n - x 元函数。

使用没有上下文的偏函数

　　bind能够实现偏函数应用，可是若是想固定一些参数，但不绑定this呢？

　　内置的bind不容许这样，咱们不能忽略上下文并跳转到参数。幸运的是，能够仅绑定参数partial函数容易实现。以下：

function partial(func, ...argsBound) { return function(...args) { return func.call(this, ...argsBound, ...args); } } let user = { firstName: "John", say(time, phrase) { alert(`[${time}] ${this.firstName}: ${phrase}!`); } }; // 偏函数，绑定第一个参数，say的time
user.sayNow = partial(user.say, new Date().getHours() + ':' + new Date().getMinutes()); //调用新函数提供第二个参数phrase
user.sayNow("Hello"); // [10:00] Hello, John!

　　调用partial(func[, arg1, arg2...])函数的结果为调用func的包装器（即第一个return的函数）：

　　（1）this一致（由于user.sayNow是经过user调用的）

　　（2）而后给其...argsBound—— partial使用该参数("10:00")进行调用。

　　（3）而后提供参数...args——提供给包装器的参数(“Hello“)

　　因此使用spread运算符很容易实现。

柯里化实现

　　有时人们混淆上面说起的偏函数和“柯里化”函数功能，柯里化是另外一个有趣的处理函数技术。柯里化（Currying）：转换一个调用函数f(a,b,c)为f(a)(b)(c)方式调用。让咱们实现柯里化函数，执行一个两元参数函数，即转换f(a,b)至f(a)(b)：

function curry(func) { return function(a) { return function(b) { return func(a, b); }; }; } // usage
function sum(a, b) { return a + b; } let carriedSum = curry(sum); alert( carriedSum(1)(2) ); // 3

　　上面是经过一系列包装器实现的。

　　（1）curry(func)的结果是function(a)的一个包装器。

　　（2）当调用sum(1)是，参数被保存在词法环境中，而后返回新的包装器function(b)

　　（3）而后sum(1)(2)提供2并最终调用function(b)，而后传递调用给原始多参数函数sum。

高级柯里化实现

　　有一些柯里化的高级实现，能够实现更复杂功能：其返回一个包装器，它容许函数提供所有参数被正常调用，或返回偏函数。实现以下：

function curry(func) { return function curried(...args) { if (args.length >= func.length) {//若是参数大于等于函数参数，那么容许函数提供所有参数被正常调用
      return func.apply(this, args); } else {//提供参数小于函数参数，返回偏函数
      return function pass(...args2) { return curried.apply(this, args.concat(args2)); } } }; } function sum(a, b, c) { return a + b + c; } let curriedSum = curry(sum); // 提供所有参数，正常调用
alert( curriedSum(1, 2, 3) ); // 6 // 返回偏函数包装器，并提供二、3参数
alert( curriedSum(1)(2,3) ); // 6

　　当咱们运行时，有两个分支：

　　一、提供所有参数正常调用：若是传递args数与原函数已经定义的参数个数同样或更长，那么直接调用。

　　二、得到偏函数：不然，不调用func函数，返回另外一个包装器，提供链接以前的参数一块儿作为新参数从新应用curried。而后再次执行一个新调用，返回一个新偏函数（若是参数不够）或最终结果。

　　举例，让咱们看sum(a, b, c)会怎样，三个参数，因此sum.length=3；

　　若是调用curried(1)(2)(3)：

　　（1）第一次调用curried(1)，在词法环境中记住1，返回包装器pass；

　　（2）使用参数2调用包装器pass：其带着前面的参数1，链接他们而后调用curried(1,2)，由于参数数量仍然小于3，返回包装器pass；

　　（3）再次使用参数3调用包装器pass，带着以前的参数(1,2)，而后增长3，并调用curried(1,2,3)——最终有三个参数，传递给原始函数，而后参数个数相等，就直接调用func函数。

总结

　　一、当把已知函数的一些参数固定，结果函数被称为偏函数。经过使用bind得到偏函数，也有其余方式实现。

　　用途：当咱们不想一次一次重复相同的参数时，偏函数是很便捷的。如咱们有send(from,to)函数，若是from老是相同的，可使用偏函数简化调用。

　　二、柯里化是转换函数调用从f(a,b,c)至f(a)(b)(c)，Javascript一般既实现正常调用，也实现参数数量不足时的偏函数方式调用。

　　用途：（1）参数复用；（2）提早返回；（3）延迟计算或运行，参数随意设置。

　　这里说一下“提早返回”，很常见的一个例子：兼容现代浏览器以及IE浏览器的事件添加方法。咱们正常状况可能会这样写：

var addEvent = function(el, type, fn, capture) { if (window.addEventListener) { el.addEventListener(type, function(e) { fn.call(el, e); }, capture); } else if (window.attachEvent) { el.attachEvent("on" + type, function(e) { fn.call(el, e); }); } };

　　上面的方法有什么问题呢？很显然，咱们每次使用addEvent为元素添加事件的时候，(eg. IE6/IE7)都会走一遍if...else if ...其实只要一次断定就能够了，怎么作？——柯里化。改成下面这样子的代码：

var addEvent = (function(){ if (window.addEventListener) { return function(el, sType, fn, capture) { el.addEventListener(sType, function(e) { fn.call(el, e); }, (capture)); }; } else if (window.attachEvent) { return function(el, sType, fn, capture) { el.attachEvent("on" + sType, function(e) { fn.call(el, e); }); }; } })();

　　初始addEvent的执行其实只实现了部分的应用（只有一次的if...else if...断定），而剩余的参数应用都是其返回函数实现的，典型的柯里化思想。