柯里化是把「接受多個參數的函數」轉換成「可以逐個接收參數」的技術。它的演進史本身就是一部 JavaScript 能力擴張史,值得回顧一下。
最早期(2005 年前後)的 curry 函數帶有一點多型的意味,單純根據傳入參數的個數在函數內部選分支:
// https://www.openlaszlo.org/pipermail/laszlo-user/2005-March/000350.html
function add(a, b) {
if (arguments.length < 1) {
return add;
} else if (arguments.length < 2) {
return function(c) { return a + c }
} else {
return a + b;
}
}
var myadd = add(2);
var total = myadd(3);
有位日本開發者可能在還不知道「arguments 也能用 Array 的原生方法轉為陣列」的時候,用非常複雜的正則與 eval 搞出了一個更接近現代 currying 意味的函數:
function curry(fun) {
if (typeof fun != 'function') {
throw new Error("The argument must be a function.");
}
if (fun.arity == 0) {
throw new Error("The function must have more than one argument.");
}
var funText = fun.toString();
var args = /function .*\((.*)\)(.*)/.exec(funText)[1].split(', ');
var firstArg = args.shift();
var restArgs = args.join(', ');
var body = funText.replace(/function .*\(.*\) /, "");
var curriedText =
"function (" + firstArg + ") {" +
"return function (" + restArgs + ")" + body +
"}";
eval("var curried =" + curriedText);
return curried;
}
思路是把函數轉成字串、用正則拆出參數清單與函數主體,再重新拼出一個新的函數字串丟給 eval 執行。寫法確實驚人,但也異常脆弱——註解、非標準格式、箭頭函數都會讓它直接失效。
接著閉包的普及,加上「arguments 可以轉成真陣列」這個發現,現代 currying 函數終於登場。這就像 15 到 17 世紀大航海時代的地理大發現,JavaScript 的世界突然開闊了許多。
// 一個簡單的現代 currying 函數
function curry(fn, scope) {
var scope = scope || window;
var args = [];
for (var i = 2, len = arguments.length; i < len; ++i) {
args.push(arguments[i]);
};
return function() {
fn.apply(scope, args);
};
}
一般的 currying 只有兩重:第一次執行參數不足就回傳內部函數,第二次執行才真正完成。但針對參數這件事,我們還是可以做點文章。看下面這個函數:
function sum(){
var result = 0;
for (var i = 0, n = arguments.length; i < n; i++) {
result += arguments[i];
}
return result;
}
alert(sum(1, 2, 3, 4, 5)); // 15
這裡沒有「參數不足」的問題,傳一個參數它也照算。那如果不傳參數呢?差別就在於「有沒有參數」。我們可以讓它只要有參數就不斷執行自身、把參數存起來,直到完全沒有參數時再一次過執行完畢。換言之,前面的步驟都是在儲存參數。
var sum2 = curry(sum); sum2 = sum2(1)(2)(3)(4)(5); sum2(); // 15
比起一般的 currying,這多了一層難度。具體看註解:
var curry = function(fn) { // 原函數的參數為函數
return function(args) { // 內部函數的參數為陣列
// 由於立即執行,因此直接到第三重去
// args 是相對於第三重內部函數而言的全域變數
var self = arguments.callee; // 把自身保存起來(就是那個以陣列為參數的第二重函數)
return function() { // 這才是第二次呼叫的函數
if (arguments.length) { // 如果還有要添加的參數
[].push.apply(args, arguments); // 把當前傳入的所有參數放進 args
return self(args);
} else {
return fn.apply(this, args); // args 是陣列,正好符合 apply 的第二參數
}
}
}([]);
};
完整可執行的版本:
function sum(){
var result = 0;
for (var i = 0, n = arguments.length; i < n; i++) {
result += arguments[i];
}
return result;
};
var curry = function(fn){
return function(args){
var self = arguments.callee;
return function(){
if (arguments.length) {
[].push.apply(args, arguments);
return self(args);
}
else return fn.apply(this, args);
}
}([]);
};
var sum2 = curry(sum);
sum2 = sum2(1)(2)(3)(4)(5);
alert(sum2());
也可以每次傳入多個參數:
var sum2 = curry(sum); sum2 = sum2(1, 2, 3); sum2 = sum2(4, 5, 6); sum2 = sum2(7, 8, 9); alert(sum2());
上面的寫法有個不足:最後總是要補一對空括號。我們希望的是「參數夠了就回傳結果,多餘的忽略」。改良如下:
function curry(f) {
if (f.length == 0) return f;
function iterate(args) {
if (args.length <= f.length)
return f.apply(null, args);
return function () {
return iterate(args.concat(Array.prototype.slice.call(arguments)));
};
}
return iterate([]);
}
這裡用 f.length 取得函數的形式參數個數作為「足夠」的判斷依據,一旦累積的參數數量達到或超過它就立刻執行。用 Array.prototype.slice.call(arguments) 把 arguments 轉成真陣列,再用 concat 累加,每次都回傳新的 iterate 結果,形成優雅的遞迴鏈。
arguments.callee 在嚴格模式下已被禁用,現代寫法應該用具名函數表達式自我參照:var recur = function self(args) { ... return self(args); }。
另外要留意,currying 與 partial application(部分應用)嚴格來說不是同一件事:currying 是「一次收一個參數,收滿才執行」,partial application 是「先固定部分參數,回傳一個參數更少的函數」。實務上兩者常被混用,而上面最後那個改良版其實更接近後者。ES6 之後,也可以用 rest 參數與展開語法寫得更乾淨:
const curry = (fn, ...args1) =>
args1.length >= fn.length
? fn(...args1)
: (...args2) => curry(fn, ...args1, ...args2);