DIV CSS 佈局教程網

深入解析 JavaScript 中的函數柯裡化(Currying)
編輯:關於JavaScript     

引子

先看一道小題。有人在群裡出了一道題:

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 裡,柯裡化雖可行(借助高階函數),語法上卻不夠便利。這也是我們決定編寫一個柯裡化函數、替我們分擔瑣事的原因,好讓代碼更簡潔。

創建一個 curry 輔助函數

理論上,我們希望能有個便利的方式,把普通的老式 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 那樣的柯裡化函數了。而且,如果我想一次傳多個參數,照舊用逗號分隔就行,不必再忍受參數之間那一層層醜陋的括號——即便它是柯裡化後的函數。

柯裡化與「洞」(holes)

柯裡化函數已經很厲害了,但它也逼著你多花心思去安排參數的順序。畢竟,柯裡化的核心思路,就是通過分步應用,把通用功能逐步分離、逐步特化。而這一切,只有在「最左參數恰好是你想分步應用的參數」時才行得通。

為了解決這個問題,一些函數式語言會定義一個特殊的「占位變量」,通常用下劃線表示:作為參數傳入時,它表明這個位置「可以跳過」、尚待指定。當你想分步應用某個函數、卻又希望跳過的並非最左參數時,這就特別有用。

舉個例子,我們有這樣一個函數:

 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") ); 

這三個例子在功能上等價。我有意把它們寫得盡可能簡單。主觀上說,我認為最後那個函數式版本,最能體現函數式編程背後的威力。

關於 curry 性能的備註

有些極度在意性能的朋友可能會問:這些額外的開銷怎麼辦?通常來說,使用柯裡化確實會有一些開銷,會不會明顯影響你,取決於你在做什麼。也就是說,我敢說絕大多數情況下,代碼的性能瓶頸首先來自別處,而非這裡。關於性能,有幾點值得牢記:

  • 訪問 arguments 對象通常比訪問命名參數稍慢;
  • 一些老版本瀏覽器在 arguments.length 上的實現相當慢;
  • 使用 fn.apply(…) 和 fn.call(…) 通常比直接 fn(…) 稍慢;
  • 創建大量嵌套作用域與閉包函數會帶來開銷,無論在內存還是速度上;
  • 在大多數 web 應用中,「瓶頸」往往出在 DOM 操作上。這說明,性能問題很少出在上面這些地方,用不用這套代碼,自行權衡即可。
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved