在一些纯粹的函数是编程语言中。函数并不描述为被调用（called或invoked），而是描述为应用（applied）。Javascript虽然不是纯粹的函数式变成语言但是也可以做同样的事情。
Curry化：在计算机科学中，柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数的新函数
例子：
未Curry化：
function add(x, y) {
return x + y;
}
add(4, 5) // 9
Curry化：
function add(x) {
return function (y) {
return x + y;
}
}
add(4)(5) //9
var f = add(6);
f(2) //8
add(10, 20) //30
通用Curry函数：
function sub_curry (fn) {
var slice = Array.prototype.slice,
oldArgs = slice.call(arguments, 1);
return function () {
var newArgs = slice.call(arguments);
var args = oldArgs.concat(newArgs);
return fn.apply(null, args);
}
}
function curry(fn, length) {
// capture fn's # of parameters
length = length || fn.length;
return function () {
if (arguments.length < length) {
// not all arguments have been specified. Curry once more.
var combined = [fn].concat(toArray(arguments));
return length - arguments.length > 0
? curry(sub_curry.apply(this, combined), length - arguments.length)
: sub_curry.call(this, combined );
} else {
// all arguments have been specified, actually call function
return fn.apply(this, arguments);
}
};
}
function add (x, y, z) {
return x + y +z;
}
var fn = curry(add);
fn(1, 2, 3);
fn(1, 2)(3);
fn(1)(2, 3);
fn(1)(2)(3);
// 6
Curry的应用场景：
函数柯里化允许和鼓励你分隔复杂功能变成更小更容易分析的部分。这些小的逻辑单元显然是更容易理解和测试的，然后你的应用就会变成干净而整洁的组合，由一些小单元组成的组合。
- 提高适用性：
function square(i) {
return i * i;
}
function double(i) {
return i *= 2;
}
function map(handeler, list) {
return list.map(handeler);
}
// 数组的每一项平方
map(square, [1, 2, 3, 4, 5]);
map(square, [6, 7, 8, 9, 10]);
map(square, [10, 20, 30, 40, 50]);
// ......
// 数组的每一项加倍
map(double, [1, 2, 3, 4, 5]);
map(double, [6, 7, 8, 9, 10]);
map(double, [10, 20, 30, 40, 50]);
例子中，创建了一个map通用函数，用于适应不同的应用场景。显然，通用性不用怀疑。同时，例子中重复传入了相同的处理函数：square和dubble。
curry化改造，固定第一个参数，缩小函数适用范围：
var mapSQ = curry(map, square);
mapSQ([1, 2, 3, 4, 5]);
mapSQ([6, 7, 8, 9, 10]);
mapSQ([10, 20, 30, 40, 50]);
// ......
var mapDB = curry(map, dubble);
mapDB([1, 2, 3, 4, 5]);
mapDB([6, 7, 8, 9, 10]);
mapDB([10, 20, 30, 40, 50]);
- 延迟执行
柯里化的另一个应用场景是延迟执行。不断的柯里化，累积传入的参数，最后执行。
var add = function() {
var _this = this,
_args = arguments
return function() {
if (!arguments.length) {
var sum = 0;
for (var i = 0,
c; c = _args[i++];) sum += c
return sum
} else {
Array.prototype.push.apply(_args, arguments) return arguments.callee
}
}
}
add(1)(2)(3)(4)();//10
- 固定易变因素
柯里化特性决定了它这应用场景。提前把易变因素，传参固定下来，生成一个更明确的应用函数。最典型的代表应用，是bind函数用以固定this这个易变对象。
Function.prototype.bind = function(context) {
var _this = this,
_args = Array.prototype.slice.call(arguments, 1);
return function() {
return _this.apply(context, _args.concat(Array.prototype.slice.call(arguments)))
}
}
参考：
http://www.cnblogs.com/pigtail/p/3447660.html
http://blog.jobbole.com/77956/