curry函数应用于多个参数列表，而不仅仅是 一个。

这是一个常规的、非咖喱的函数，它加了两个Int 参数x和y:

scala> def plainOldSum(x: Int, y: Int) = x + y
plainOldSum: (x: Int,y: Int)Int
scala> plainOldSum(1, 2)
res4: Int = 3

这是一个类似的咖喱函数。而不是 对于一个包含两个Int形参的列表，您将此函数应用于两个包含一个Int形参的列表 Int参数each:

scala> def curriedSum(x: Int)(y: Int) = x + y
curriedSum: (x: Int)(y: Int)Intscala> second(2)
res6: Int = 3
scala> curriedSum(1)(2)
res5: Int = 3

这里发生的事情是，当您调用curriedSum时，实际上会得到两个背对背的传统函数调用。第一个函数 调用接受一个名为x的Int形参，并返回一个函数 为第二个函数。第二个函数接受Int形参 y。

这里有一个名为first的函数，它在精神上完成了第一个传统函数 函数调用curriedSum会做:

scala> def first(x: Int) = (y: Int) => x + y
first: (x: Int)(Int) => Int

对第一个函数应用1——换句话说，调用第一个函数 而传入1 -会得到第二个函数:

scala> val second = first(1)
second: (Int) => Int = <function1>

对第二个函数应用2得到的结果是:

scala> second(2)
res6: Int = 3

我发现这篇文章，以及它引用的文章，有助于更好地理解咖喱: http://blogs.msdn.com/wesdyer/archive/2007/01/29/currying-and-partial-function-application.aspx

正如其他人所提到的，它只是一种具有单参数函数的方法。

这很有用，因为你不需要假设有多少参数将被传入，所以你不需要2个参数，3个参数和4个参数函数。

在函数代数中，处理带有多个参数的函数(或相当于一个n元组的参数)有点不优雅——但是，正如Moses Schönfinkel(以及Haskell Curry)所证明的那样，这是不需要的:您所需要的只是带有一个参数的函数。

那么如何处理自然表示为f(x,y)的式子呢?好吧，你把它等价于f(x)(y)——f(x)，叫它g，是一个函数，你把这个函数应用到y上。换句话说，你只有带一个参数的函数——但其中一些函数返回其他函数(也带一个参数;-)。

像往常一样，维基百科对此有一个很好的总结条目，有许多有用的指针(可能包括关于你最喜欢的语言的;-)，以及稍微更严格的数学处理。

curry是Java Script的高阶函数之一。

curry是一个包含许多参数的函数，它会被重写，这样它会接受第一个参数并返回一个函数，而这个函数会使用剩余的参数并返回值。

困惑吗?

让我们看一个例子，

function add(a,b)
    {
        return a+b;
    }
add(5,6);

这类似于下面的咖喱函数，

function add(a)
    {
        return function(b){
            return a+b;
        }
    }
var curryAdd = add(5);
curryAdd(6);

那么这个代码是什么意思呢?

现在再读一遍定义，

curry是一个包含许多参数的函数，它被重写为接受第一个参数并返回一个函数，该函数反过来使用剩余的参数并返回值。

不过,困惑吗? 让我来详细解释一下!

当你调用这个函数时，

var curryAdd = add(5);

它会返回一个这样的函数，

curryAdd=function(y){return 5+y;}

这叫做高阶函数。也就是说，依次调用一个函数返回另一个函数是高阶函数的精确定义。这是图例的最大优势，Java Script。 回到咖喱，

这一行将把第二个参数传递给curryAdd函数。

curryAdd(6);

结果是，

curryAdd=function(6){return 5+6;}
// Which results in 11

希望你能理解这里咖喱的用法。 那么，说到优点，

为什么鞭笞?

它利用了代码可重用性。 代码越少，错误越少。 你可能会问它是怎么少代码的?

我可以证明它与ECMA脚本6新的特征箭头功能。

是的!ECMA 6，为我们提供了美妙的功能，叫做箭头函数，

function add(a)
    {
        return function(b){
            return a+b;
        }
    }

借助箭头函数，我们可以将上面的函数写成如下形式:

x=>y=>x+y

酷吧?

所以，更少的代码和更少的错误!!

在这些高阶函数的帮助下，可以很容易地开发出无bug的代码。

我向你挑战!

霍普，你知道什么是咖喱。如果你有任何需要澄清的地方，请在这里评论。

谢谢，祝您愉快!

curry是将函数从可调用的f(a, b, c)转换为可调用的f(a)(b)(c)。

另外，curry是指将一个接受多个参数的函数分解为一系列接受部分参数的函数。

从字面上看，curry是函数的转换:从一种调用方式到另一种调用方式。在JavaScript中，我们通常创建一个包装器来保留原始函数。

curry不调用函数。它只是变换了它。

让我们创建一个curry函数，它对双实参函数执行curry。换句话说，对于双参数f(a, b)的curry(f)将其转换为f(a)(b)

function curry(f) { // curry(f) does the currying transform
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}

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

let carriedSum = curry(sum);

alert( carriedSum(1)(2) ); // 3

如您所见，实现是一系列的包装器。

curry(func)的结果是一个包装器函数(a)。 当它像sum(1)一样被调用时，参数被保存在词法环境中，并返回一个新的包装器函数(b)。 然后sum(1)(2)最后调用函数(b)提供2，它将调用传递给原始的多参数sum。

curry是指将一个N次的函数转换为N次1次的函数。函数的元数是它所需要的参数的个数。

下面是正式的定义:

 curry(f) :: (a,b,c) -> f(a) -> f(b)-> f(c)

下面是一个真实的例子:

你去自动取款机取钱。你刷你的卡，输入密码，做出选择，然后按enter键提交“金额”和请求。

这是取款的正常功能。

const withdraw=(cardInfo,pinNumber,request){
    // process it
       return request.amount
}

在这个实现函数中，我们希望一次性输入所有参数。我们将刷卡，输入密码并发出请求，然后函数将运行。如果这些步骤中有任何问题，在输入所有参数后就会发现。使用curry函数，我们可以创建更高的、纯粹的和简单的函数。纯函数将帮助我们轻松地调试代码。

这是带有咖喱功能的Atm机。

const withdraw=(cardInfo)=>(pinNumber)=>(request)=>request.amount

ATM, takes the card as input and returns a function that expects pinNumber and this function returns a function that accepts the request object and after the successful process, you get the amount that you requested. Each step, if you had an error, you will easily predict what went wrong. Let's say you enter the card and got error, you know that it is either related to the card or machine but not the pin number. Or if you entered the pin and if it does not get accepted you know that you entered the pin number wrong. You will easily debug the error.

此外，这里的每个函数都是可重用的，因此您可以在项目的不同部分使用相同的函数。