“Currying”是一个获取多个参数的函数并将其转换为一系列函数的过程，每个函数接受一个参数并返回一个参数的函数，或者在最终函数的情况下，返回实际结果。

curry是指将一个接受多个参数的函数分解为一系列函数，每个函数只接受一个参数。下面是JavaScript的一个例子:

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

add(3, 4); // returns 7

这是一个接受两个参数a和b的函数，并返回它们的和。现在我们将咖喱这个函数:

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

这是一个接受一个参数a的函数，并返回一个接受另一个参数b的函数，该函数返回它们的和。

add(3)(4); // returns 7

var add3 = add(3); // returns a function

add3(4); // returns 7

第一个语句返回7，就像add(3,4)语句一样。 第二条语句定义了一个名为add3的新函数 给它的参数加上3。(这就是有些人所说的终结。) 第三条语句再次使用add3操作将3添加到4 结果是7。

正如所有其他答案一样，咖喱有助于创建部分应用函数。Javascript不提供自动咖喱的原生支持。因此，上面提供的示例可能对实际编码没有帮助。在livescript中有一些很好的例子(基本上编译成js) http://livescript.net/

times = (x, y) --> x * y
times 2, 3       #=> 6 (normal use works as expected)
double = times 2
double 5         #=> 10

在上面的例子中，当你给出较少的no of参数时，livescript会为你生成新的curried函数(double)

这里有一个具体的例子:

假设你有一个计算作用在物体上的引力的函数。如果你不知道公式，你可以在这里找到。这个函数接受三个必要的形参作为参数。

现在，在地球上，你只想计算这个星球上物体的力。在函数式语言中，你可以把地球的质量传递给函数，然后对它进行部分计算。你会得到另一个函数，它只接受两个参数，并计算地球上物体的引力。这叫做咖喱。

它可以是一种用函数生成其他函数的方法。

在javascript中:

let add = function(x){
  return function(y){ 
   return x + y
  };
};

我们可以这样称呼它:

let addTen = add(10);

运行时，将10作为x传入;

let add = function(10){
  return function(y){
    return 10 + y 
  };
};

这意味着我们返回这个函数:

function(y) { return 10 + y };

所以当你打电话的时候

 addTen();

你真的在呼唤:

 function(y) { return 10 + y };

如果你这样做:

 addTen(4)

这就相当于:

function(4) { return 10 + 4} // 14

所以我们的addTen()总是给我们传入的任何东西加10。我们可以用同样的方法来构造类似的函数:

let addTwo = add(2)       // addTwo(); will add two to whatever you pass in
let addSeventy = add(70)  // ... and so on...

接下来的问题是，你到底为什么要这么做?它将一个急迫的操作x + y变成了一个可以轻松完成的操作，这意味着我们至少可以做两件事 1. 缓存昂贵的操作 2. 在功能范式中实现抽象。

想象我们的咖喱函数是这样的:

let doTheHardStuff = function(x) {
  let z = doSomethingComputationallyExpensive(x)
  return function (y){
    z + y
  }
}

我们可以调用这个函数一次，然后将结果传递给很多地方，这意味着我们只做一次计算上昂贵的事情:

let finishTheJob = doTheHardStuff(10)
finishTheJob(20)
finishTheJob(30)

我们可以用类似的方式得到抽象。

curry是一种可以应用于函数的转换，允许它们比以前少接受一个参数。

例如，在f#中你可以这样定义一个函数:-

let f x y z = x + y + z

这里函数f取参数x, y和z，并将它们相加:-

f 1 2 3

返回6。

根据我们的定义，我们可以定义f的curry函数:-

let curry f = fun x -> f x

其中'fun x - >fx '是一个lambda函数，在c#中等价于x => f(x)。此函数输入您希望curry的函数，并返回一个接受单个参数的函数，并返回指定的函数，其中第一个参数设置为输入参数。

使用前面的例子，我们可以得到f的curry值:-

let curryf = curry f

然后我们可以做以下的事情:-

let f1 = curryf 1

这为我们提供了一个函数f1，它等价于f1 y z = 1 + y + z。这意味着我们可以做以下事情

f1 2 3

返回6。

这个过程经常与“部分函数应用”相混淆，可以这样定义:-

let papply f x = f x

尽管我们可以将其扩展为多个参数，即:-

let papply2 f x y = f x y
let papply3 f x y z = f x y z
etc.

部分应用程序将接受函数和形参并返回一个需要一个或多个更少形参的函数，正如前面两个示例所示，它直接在标准f#函数定义中实现，因此我们可以通过以下方式实现前面的结果

let f1 = f 1
f1 2 3

它将返回一个6的结果。

结论:-

咖喱和部分函数应用的区别是:-

curry接受一个函数，并提供一个接受单个参数的新函数，并返回指定函数，并将其第一个参数设置为该参数。这允许我们将具有多个形参的函数表示为一系列单实参函数。例子:-

let f x y z = x + y + z
let curryf = curry f
let f1 = curryf 1
let f2 = curryf 2
f1 2 3
6
f2 1 3
6

偏函数应用更直接——它接受一个函数和一个或多个参数，并返回一个函数，其中前n个参数设置为指定的n个参数。例子:-

let f x y z = x + y + z
let f1 = f 1
let f2 = f 2
f1 2 3
6
f2 1 3
6