JavaScript 與其他動態語言一樣,天生適合寫高階函式——所謂高階函式,就是「能夠操作函式的函式」。之所以做得到,是因為在 JavaScript 裡函式是徹頭徹尾的物件,屬於第一類公民(first-class citizen):它可以被賦值給變數、當成參數傳入、也能作為回傳值。這正是函數式編程得以成立的先決條件。
下面這個例子出自一本 JavaScript 教材,功能是計算一組數值的平均值與標準差。先列出最直覺的迴圈版本:
var data = [1, 1, 3, 5, 5];
var total = 0;
for (var i = 0; i < data.length; i++) total += data[i];
var mean = total / data.length; // 平均值為 3
// 計算標準差
total = 0;
for (var i = 0; i < data.length; i++) {
var deviation = data[i] - mean;
total += deviation * deviation;
}
var stddev = Math.sqrt(total / (data.length - 1)); // 標準差為 2
邏輯完全正確,問題在於它把「怎麼做」寫死了:迴圈、累加器、暫存變數全都攤在眼前,一旦要組合新的計算流程,就得再寫一遍同樣的骨架。
改用函數式風格之前,我們先定義一批 helper:
// 把類陣列物件轉成真正的陣列
function array(a, n) { return Array.prototype.slice.call(a, n || 0); }
// 把函式的實參固定在最左側
function partial_left(f) {
var args = arguments;
return function () {
var a = array(args, 1);
a = a.concat(array(arguments));
return f.apply(this, a);
};
}
// 把函式的實參固定在最後
function partial_right(f) {
var args = arguments;
return function () {
var a = array(arguments);
a = a.concat(array(args, 1));
return f.apply(this, a);
};
}
// 以模板方式預先填入參數,undefined 的位置由實際傳入的參數補上
function partial(f) {
var args = arguments;
return function () {
var a = array(args, 1);
var i = 0, j = 0;
for (; i < a.length; i++) if (a[i] === undefined) a[i] = arguments[j++];
a = a.concat(array(arguments, j));
return f.apply(this, a);
};
}
// 回傳一個效果等同 f(g(...)) 的函式
function compose(f, g) {
return function () { return f.call(this, g.apply(this, arguments)); };
}
var data = [1, 1, 3, 5, 5];
var sum = function (x, y) { return x + y; };
var product = function (x, y) { return x * y; };
var neg = partial(product, -1); // 求相反數
var square = partial(Math.pow, undefined, 2); // 平方
var sqrt = partial(Math.pow, undefined, 0.5); // 開平方
var reciprocal = partial(Math.pow, undefined, -1); // 倒數
// 平均值
var mean = product(reduce(data, sum), reciprocal(data.length));
// 標準差
var stddev = sqrt(product(
reduce(map(data, compose(square, partial(sum, neg(mean)))), sum),
reciprocal(sum(data.length, -1))
));
除了 reduce 與 map,其他函式前面都定義好了。reduce 有點像 Ruby 的 inject:
ary = (1..10).to_a
ary.inject(0) { |sum, i| sum + i } // 結果為 55
JavaScript 的對應寫法:
var ary = [1,2,3,4,5,6,7,8,9,10];
ary.reduce(function (sum, i) { return sum + i; }, 0);
第二個參數 0 是累加器的初始值,省略時會改用陣列的第一個元素,這裡可以省。而 map 更單純:對陣列的每個元素套用同一個操作,回傳一個全新的陣列。以 Ruby 對照:
a = (1..3).to_a # [1, 2, 3]
a.map { |x| x * 2 } # 回傳新陣列 [2, 4, 6]
先看幾個基礎函式對應的意義:sum 與 product 分別是相加與相乘;neg 等同 product(-1, x);square 等同 Math.pow(x, 2),注意 partial 的第二個參數是 undefined,意思是這個形參留給 later 傳入的實參填補,所以 square(x) 就是 Math.pow(x, 2);sqrt 等同 Math.pow(x, 0.5);reciprocal 等同 Math.pow(x, -1),也就是倒數。
平均值的算法很直白:先把陣列元素加總,再乘上長度的倒數,等於「總和 ÷ 長度」。
標準差看起來嚇人,最好的讀法是「由內而外」剝洋蔥。
最內層含 neg 的那段:
partial(sum, neg(mean)) // 等同 function (x) { return sum(-1 * mean, x); }
接著是 compose:
compose(square, partial(sum, neg(mean))) // 逐層展開:square(sum(-1 * mean + x)) // 再展開:Math.pow(sum(-1 * mean + x), 2)
然後是 map:把 data 的每個元素當成 x 丟進上面的函式,得到一個新陣列,每個元素都是「原元素減去平均值後的平方」。
map(data, Math.pow(sum(-1 * mean + x), 2))
外層的 reduce 負責把新陣列的值全部加起來:
reduce(map(...), sum)
再來是 reciprocal:
reciprocal(sum(data.length, -1)) // 等同 1 / (data.length - 1)
而 product 把「平方差的總和」乘上這個倒數,效果就是除以 (data.length - 1)。最外層的 sqrt 再對整個商開平方根。
對照最開頭的命令式版本,兩邊算的是同一件事。看起來很嚇人的一大坨程式碼,攤開逐層分析之後難度立刻歸零。函數式風格的價值也在這裡浮現:每個小函式都單純、可獨立測試,組合方式則由 compose 與 partial 明確表達,而不是散落在迴圈與暫存變數之間。