引子
先看一道小題。有人在群裡出了一道題:
var s = sum(1)(2)(3) ....... 最後 alert(s) 出來是 6
var s = sum(1)(2)(3)(4) ....... 最後 alert(s) 出來是 10
問 sum 該怎麼實現?
剛看到題目,我的第一反應是:sum 返回的應該是一個 function,但具體怎麼落地卻沒頭緒,印象中見過類似原理,一時又想不起來。後來同事提醒,這叫柯裡化,實現起來頗為巧妙:
function sum(x){ var y = function(x){ return sum(x+y) } y.toString = y.valueOf = function(){ return x; } return y; }
下面就讓我們深入看看柯裡化(currying)。
柯裡化是一個轉換過程:把接受多個參數的函數,變換成只接受單一參數(最初函數的第一個參數)的函數;若還需要其餘參數,則返回一個接受剩餘參數並返回結果的新函數。
這麼一說,柯裡化聽起來似乎挺簡單。那在 JavaScript 裡該怎麼實現呢?假設我們要寫一個接受 3 個參數的函數:
var sendMsg = function (from, to, msg) { alert(["Hello " + to + ",", msg, "Sincerely,", "- " + from].join("\n")); };
現在,假設我們有一個柯裡化函數,能把傳統的 JS 函數轉換成柯裡化後的函數:
var sendMsgCurried = curry(sendMsg); // returns function(a,b,c) var sendMsgFromJohnToBob = sendMsgCurried("John")("Bob"); // returns function(c) sendMsgFromJohnToBob("Come join the curry party!"); //=> "Hello Bob, Come join the curry party! Sincerely, - John"
上面的例子裡,我們預設了有個神奇的 curry 函數。我會實現它,但在此之前,先看看為什麼這樣的函數如此必要。手動柯裡化一個函數並不難,只是有點囉嗦:
// uncurried var example1 = function (a, b, c) { // do something with a, b, and c }; // curried var example2 = function(a) { return function (b) { return function (c) { // do something with a, b, and c }; }; };
在 JavaScript 裡,即使你不傳全部參數,函數照樣會被調用。這是個非常實用的特性,卻也給柯裡化添了麻煩。
思路是:讓每個函數都恰好只有一個參數。想要多個參數,就得定義一串相互嵌套的函數。一次兩次還能忍受,可一旦要定義需要大量參數的函數,這種寫法就變得冗長又難讀。(別擔心,我馬上就給你支招。)
一些函數式語言,比如 Haskell 和 OCaml,語法裡就內置了柯裡化。在這些語言中,每個函數都只有一個參數。你可能覺得這種限制弊大於利,但由於語法使然,這種限制幾乎讓人察覺不到。
舉例來說,在 OCaml 裡,你可以用兩種方式定義上面的 example:
let example1 = fun a b c -> // (* do something with a, b, c *) let example2 = fun a -> fun b -> fun c -> // (* do something with a, b, c *)
不難看出,這兩個例子與前面那兩個是多麼相似。區別在於,OCaml 其實並沒有做什麼特殊的事——它根本沒有「多參數函數」的概念。在一行裡聲明多個參數,只不過是嵌套定義單參函數的「快捷鍵」而已。
類似的,我們期望柯裡化函數在調用時能像 OCaml 那樣簡潔:
example1 foo bar baz example2 foo bar baz
而在 JavaScript 裡,我們則要用明顯不同的方式:
example1(foo, bar, baz); example2(foo)(bar)(baz);
在 OCaml 這類語言中,柯裡化是內建的;而在 JavaScript 裡,柯裡化雖可行(借助高階函數),語法上卻不夠便利。這也是我們決定編寫一個柯裡化函數、替我們分擔瑣事的原因,好讓代碼更簡潔。
理論上,我們希望能有個便利的方式,把普通的老式 JS 函數(多參數)轉換成完全柯裡化的函數。這想法並非我一人專有,其他人也實現過,比如 wu.js 庫中的 .autoCurry() 函數(當然,你關心的還是我們自己的實現)。
先來造一個簡單的輔助函數 .sub_curry:
function sub_curry(fn /*, variable number of args */ ) { var args = [].slice.call(arguments, 1); return function () { return fn.apply(this, args.concat(toArray(arguments))); }; }
花點時間看看它的功能,其實很簡單。sub_curry 接受一個函數 fn 作為首個參數,後面可跟任意數目的參數,返回一個函數;這個函數最終以「最初傳入的參數」加上「調用時傳入的參數」合併後的序列,去執行 fn.apply。
看例子:
var fn = function(a, b, c) { return [a, b, c]; }; // these are all equivalent fn("a", "b", "c"); sub_curry(fn, "a")("b", "c"); sub_curry(fn, "a", "b")("c"); sub_curry(fn, "a", "b", "c")(); //=> ["a", "b", "c"]
很明顯,這還不是我們想要的,但已經隱隱有了柯裡化的味道。接著,我們定義真正的柯裡化函數 curry:
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.prototype.length,也就是函數定義時的形參個數。
最終,我們可以驗證下面這些行為:
var fn = curry(function(a, b, c) { return [a, b, c]; }); // these are all equivalent fn("a", "b", "c"); fn("a", "b", "c"); fn("a", "b")("c"); fn("a")("b", "c"); fn("a")("b")("c"); //=> ["a", "b", "c"]
我知道你在想什麼……等等,什麼?!我們現在居然能在 JavaScript 裡寫出像 OCaml 或 Haskell 那樣的柯裡化函數了。而且,如果我想一次傳多個參數,照舊用逗號分隔就行,不必再忍受參數之間那一層層醜陋的括號——即便它是柯裡化後的函數。
柯裡化函數已經很厲害了,但它也逼著你多花心思去安排參數的順序。畢竟,柯裡化的核心思路,就是通過分步應用,把通用功能逐步分離、逐步特化。而這一切,只有在「最左參數恰好是你想分步應用的參數」時才行得通。
為了解決這個問題,一些函數式語言會定義一個特殊的「占位變量」,通常用下劃線表示:作為參數傳入時,它表明這個位置「可以跳過」、尚待指定。當你想分步應用某個函數、卻又希望跳過的並非最左參數時,這就特別有用。
舉個例子,我們有這樣一個函數:
var sendAjax = function (url, data, options) { /* ... */ }
也許我們想定義一個新函數,只固定 options,而讓 url 與 data 仍可被指定。當然,我們可以簡單地這樣寫:
var sendPost = function (url, data) { return sendAjax(url, data, { type: "POST", contentType: "application/json" }); };
或者,採用約定的下劃線方式,就像這樣:
var sendPost = sendAjax( _ , _ , { type: "POST", contentType: "application/json" });
注意這裡兩個參數都用下劃線傳入。顯然,JavaScript 並不原生支持這種寫法,那我們該如何實現呢?回過頭,把 curry 函數變得更聰明一些……
首先,把我們的「占位符」定義成一個全局變量:
var _ = {};
把它定義為對象字面量 {},是為了方便用 === 操作符判等。不管你喜不喜歡,為了簡單起見,我們就用 _ 當「占位符」。現在可以定義增強版的 curry 了:
function curry (fn, length, args, holes) { length = length || fn.length; args = args || []; holes = holes || []; return function(){ var _args = args.slice(0), _holes = holes.slice(0), argStart = _args.length, holeStart = _holes.length, arg, i; for(i = 0; i < arguments.length; i++) { arg = arguments[i]; if(arg === _ && holeStart) { holeStart--; _holes.push(_holes.shift()); // move hole from beginning to end } else if (arg === _) { _holes.push(argStart + i); // the position of the hole. } else if (holeStart) { holeStart--; _args.splice(_holes.shift(), 0, arg); // insert arg at index of hole } else { _args.push(arg); } } if(_args.length < length) { return curry.call(this, fn, length, _args, _holes); } else { return fn.apply(this, _args); } } }
實際代碼有了很大不同——我們在這裡記錄了這些「洞」參數的位置。概括而言,運行職責是一致的。看看我們的新幫手,下面這些語句都是等價的:
var f = curry(function(a, b, c) { return [a, b, c]; }); var g = curry(function(a, b, c, d, e) { return [a, b, c, d, e]; }); // all of these are equivalent f("a","b","c"); f("a")("b")("c"); f("a", "b", "c"); f("a", _, "c")("b"); f( _, "b")("a", "c"); //=> ["a", "b", "c"] // all of these are equivalent g(1, 2, 3, 4, 5); g(_, 2, 3, 4, 5)(1); g(1, _, 3)(_, 4)(2)(5); //=> [1, 2, 3, 4, 5]
是不是有點瘋狂?
你可能會停下來想:這看起來挺酷,但它真能幫我寫出更好的代碼嗎?答案是肯定的,原因有很多。
柯裡化允許並鼓勵你把複雜功能拆分為更小、更易分析的單元。這些小邏輯單元顯然更好理解、更好測試,於是整個應用就變成了由許多小單元組成的、乾淨而整潔的組合。
舉個簡單的例子,我們分別用 Vanilla.js、Underscore.js 和「函數式方式」來寫一個 CSV 解析器。
Vanilla.js(命令式)
//+ String -> [String] var processLine = function (line){ var row, columns, j; columns = line.split(","); row = []; for(j = 0; j < columns.length; j++) { row.push(columns[j].trim()); } }; //+ String -> [[String]] var parseCSV = function (csv){ var table, lines, i; lines = csv.split("\n"); table = []; for(i = 0; i < lines.length; i++) { table.push(processLine(lines[i])); } return table; }; Underscore.js //+ String -> [String] var processLine = function (row) { return _.map(row.split(","), function (c) { return c.trim(); }); }; //+ String -> [[String]] var parseCSV = function (csv){ return _.map(csv.split("\n"), processLine); };
函數式方式
//+ String -> [String] var processLine = compose( map(trim) , split(",") ); //+ String -> [[String]] var parseCSV = compose( map(processLine) , split("\n") );
這三個例子在功能上等價。我有意把它們寫得盡可能簡單。主觀上說,我認為最後那個函數式版本,最能體現函數式編程背後的威力。
有些極度在意性能的朋友可能會問:這些額外的開銷怎麼辦?通常來說,使用柯裡化確實會有一些開銷,會不會明顯影響你,取決於你在做什麼。也就是說,我敢說絕大多數情況下,代碼的性能瓶頸首先來自別處,而非這裡。關於性能,有幾點值得牢記: