详细的JS（讨好）的级联

柯里的咖喱是什么

咖喱的来源和数学家Haskell Curry的名字（编程语言Haskell也在他的名字命名的）。

腐熟通常被称为部分的评价，它的意义是功能一步一步的传输参数，各部分参数传递参数的应用，参数并返回一个更具体的函数接受其余参数的函数可接受的部分嵌套在它，直到你回来的最终结果。

因此，腐熟过程中逐渐传递参数，逐步缩小职能范围，逐步解决的过程。

Currie和功能

根据一步一步，我们看到一个简单的例子。


无功concat3words =功能（A，B，C）{
返回B+；
}；
无功concat3wordscurrying =函数（）{
返回函数（b）{
返回函数（c）{
返回B+；
}；
}；
}；
console.log（concat3words（foo
console.log（concat3wordscurrying（foo））； / / {功能}
console.log（concat3wordscurrying（foo）（条）（巴扎））； / / foo bar巴扎


可以看出，concat3wordscurrying（foo）是一个函数，每个函数返回一个新的功能。函数接受另一个调用，然后返回一个新函数，直到它返回到最终结果，并且该解决方案在不同的级别上分布。

现在，让我们进一步讨论。如果可以传递超过3个参数，则可以传递任意数量的参数，并在不传递参数时输出结果。

首先，一个共同的实现：


var =函数（项目）{
返回items.reduce（功能（A，B）{
返回A+
}）；
}；
console.log（添加（{三}））；


但是如果你需要在10之后乘以每个数字，那么：


var =函数（项目，多）{
返回items.map（功能（项目）{
返回项目*多；
}。减少（函数（A，B）{ }）
返回A+
}）；
}；
console.log（添加（{ 1, 2, 3，4 }，10））；


拥有地图和减少函数是很好的，如果你要在每个项目中添加1，那么我们需要替换地图中的函数。

看看下面的柯里：


（）{ var加法器=功能（）
无功_args = { }；
返回函数（）{
如果（arguments.length = 0）{
返回_args.reduce（功能（A，B）{
返回A+；
}）；
}
{ }。push.apply（_args，{ }。slice.call（参数））；
返回arguments.callee；
}
}；
var =加法器（）；
console.log（总和）； / /功能
求和（100200）（300）；调用灵活形式，调用可以输入一个或多个参数，并支持调用链。
总和（400）；
Console.log（（和））； / / 1000（总和）


加法器是上述咖喱的函数，它返回一个新函数，新功能可以批量接收，接受新参数，延时到最后计算。

咖喱的一般功能

更典型的钻营将最后封装成一个函数，那么这个函数作为参数传递给函数的难题，使一个明确的和灵活的。

例如，每个项目乘以10，我们可以将处理函数作为参数传递。


VaR钻营=功能（Fn）{
无功_args = { }；
返回函数（）{
如果（arguments.length = 0）{
返回fn.apply（这_args）；
}
Array.prototype.push.apply（_args，{ }。slice.call（参数））；
返回arguments.callee；
}
}；
var =函数（）{
var总= 0；
对于（var i = 0，C；C =参数{ }；}）{
总= C；
}
总收益；
}；
VaR和=腐熟（多）；
总和（100200）（300）；
总和（400）；
Console.log（（和））； / / 1000（空白叫真的计算）


所以总和=腐熟（多），电话是非常明确的，效果也是辉煌的，例如，积累多值，多个值可以作为一个参数的总和（1,2,3），它也可以支持调用链，和（1）（2）（3）。

咖喱的效果

延迟计算。上面的例子没有很好的说明。
参数重用。当对同一个函数的多个调用和大多数传输参数相同时，函数可能是一个很好的候选对象。
动态创建一个函数。


这可以基于结果的部分计算，并在此基础上动态生成一个新的功能的业务处理后，使计算重复的问题。或者我们可以通过动态传递的呼叫功能和部分功能的子集，它创建一个新的功能，而创建一个新的动态功能。这个新函数保存重复传入参数。例如，事件浏览器添加事件的辅助方法：


VaR AddEvent =功能（EL型、FN、捕捉）{
如果（窗口。addEventListener）{
El.addEventListener（类型、函数（e）{
fn.call（EL，E）；
}，捕获）；
如果（窗口。attachevent）{ }
el.attachevent（+型，功能（e）{
fn.call（EL，E）；
}）；
}
}；


每次添加事件处理时，我们都需要执行另一次操作。事实上，我们只需要判断一个浏览器，我们需要动态生成新的功能，根据结果决定的，所以我们不需要重新计算后。


VaR AddEvent =（函数（）{（）
如果（窗口。addEventListener）{
返回功能（EL型、FN、捕捉）{
El.addEventListener（体、功能（e）{
fn.call（EL，E）；
}（捕获）；
}；
如果（窗口。attachevent）{ }
返回功能（EL型、FN、捕捉）{
el.attachevent（+，功能（e）{
fn.call（EL，E）；
}）；
}；
}
}）；


在这种情况下，在第一个if之后…其他的…判断，完整的计算，新的功能来处理传入的参数，动态创建的背后，这是一个典型的阿谀奉承。

该方法是function.prototype.bind咖喱中的应用

电话/申请的方法和结合的方法将直接执行，第一个参数设置为一个执行上下文的功能，其他参数传递到调用方法（函数本身的身体是不执行的，可以看作是一个延迟执行和动态创建）返回一个新的功能，这是有咖喱的特点相一致。


var：x：888 }；
函数（）{（）
（这console.log。x）；
}绑定；
（酒吧）；
888




电话/申请的方法和结合的方法将直接执行，第一个参数设置为一个执行上下文的功能，其他参数传递到调用方法（函数本身的身体是不执行的，可以看作是一个延迟执行和动态创建）返回一个新的功能，这是有咖喱的特点相一致。


var：x：888 }；
函数（）{（）
（这console.log。x）；
}绑定；
（酒吧）；
888


下面是绑定函数的模拟。testbind创建并返回新的功能。在新函数中，真正执行业务的函数绑定到参数的上下文中，并且执行延迟。


function.prototype.testbind =功能（范围）{
无功/ FN =这；这是指一个电话到testbind功能，
返回函数（）{
返回fn.apply（范围）；
}
}；
无功testbindbar = bar.testbind（Foo）； / /富结合，延迟执行
console.log（testbindbar）； / /功能（可见，绑定后的回报是延迟执行的新功能）
testbindbar（）；


这里请注意对原型的理解。

例子

例1：


VaR钻营=功能（Fn）{
是指官方的妻子消化法。
var args = { }。slice.call（参数1）；
/ /参数是指合法妻子
返回函数（）{
有一个妻子和一个固定的妻子，很容易控制。
无功newargs = args.concat（{ }。slice.call（参数））；
这意味着使用Fn / /消化利用的是他的妻子，魏晓宝先进的技艺和回报
返回fn.apply（null，newargs）；
}；
}；
有关官员如何修复7妻子测试
合法妻子
无功getwife =腐熟（函数（））{
无功allwife = { }。slice.call（参数）；
/ / allwife是所有的妻子，包括妻子暗渡陈仓。
console.log（allwife.join（；））；
合法妻子；
得到另外6个妻子
getwife（妻子
对于一些妻子来说
getwife（超越魏晓宝的妻子）；
结果uff1a
合法妻子；大老婆；小老婆；乔的妻子；妻子刁蛮；我的妻子送回家，妻子；
一个合法的妻子；妻子超越魏晓宝
例2：
无功curryweight =功能（Fn）{
无功_fishweight = { }；
返回函数（）{
如果（arguments.length = 0）{
返回fn.apply（null，_fishweight）；
{人}
_fishweight = _fishweight.concat（{ }。slice.call（参数））；
}
}
}；
无功fishweight = 0；
无功addweight = curryweight（function（））{
var i = 0；len = arguments.length；
为了（我；我；我；+ = 1）{
fishweight =论点{我}；
}
}）；
（2.3）addweight；
（6.5）addweight；
（1.2）addweight；
（2.5）addweight；
（addweight / /这里）；计算
console.log（fishweight）； / / 12.5


总结

以上是萧边介绍的JS功能讨好（讨好），希望对你有帮助，如果您有任何问题，请给我留言，萧边会及时回复你。谢谢你的支持网站。