你的腦袋可以這樣想嗎？

2013年05月25日 12:51:47 · 本文共 3,946 字阅读时间约 14分钟 · 3,896 次浏览

本文转载自：良葛格的Blog 有一天，你在瀏覽自己的程式碼，發現有兩大段程式碼幾乎一樣。實際上它們的確一樣，除了一個關於「Spaghetti」而另一個關於「Chocolate Moose」。

System.out.println("I"d like some Spaghetti!"); System.out.println("I"d like some Chocolate Moose!");

這例子看來是Java的，不過你就算不懂Java，也應該明白在幹甚麼。重覆的程式碼是個問題。於是，你建立方法：

static void swedishChef(String food) { println("I"d like some " + food + "!"); } static void println(Object obj) { System.out.println(obj); }

swedishChef("Spaghetti!"); swedishChef("Chocolate Moose!");

嗯，這個例子很經典，但你能想到一個更深入的例子。這段程式碼的優勝之處有很多，你聽過上千次的：可維護性、可讀性、抽象性 = 好！現在你留意到有另外兩段程式碼一模一樣，除了一個反覆呼叫一個叫boomBoom的方法，另一個反覆呼叫一個喚作putInPot的。除此之外，這兩段程式碼真的像雙生的。

println("get the lobster"); putInPot("lobster"); putInPot("water");

println("get the chicken"); boomBoom("chicken"); boomBoom("coconut");

現在你需要一個辦法，使得你可以將一個流程區塊替代另一個方法中的流程區塊。這是個重要的思考，因為你更易將常用的程式碼收藏在一個方法內。

interface Block<P> { void apply(P p); } static void cook(String food1, String food2, Block cooker) { println("get the " + food1); cooker.apply(food1); cooker.apply(food2); }

cook("lobster", "water", new Block<String>() { public void apply(String food) { putInPot(food); } }); cook("chicken", "coconut", new Block<String>() { public void apply(String food) { boomBoom(food); } });

看！我們成功將流程區塊替代了。你的腦袋能想到嗎？等等，假設你未定義putInPot或boomBoom這些方法，那就直接實作在apply中，另外呼叫cook時看來有點醜，適當地使用變數，會比直接將它寫進一行內好看的多。

Block<String> putInPot = new Block<String>() { public void apply(String food) { println("pot " + food); } }; Block<String> boomBoom = new Block<String>() { public void apply(String food) { println("boom " + food);} }; cook("lobster", "water", putInPot); cook("chicken", "coconut", boomBoom);

呼叫cook時清楚多了。臨時建立匿名類別實例時，也可以適當地起名，再丟到一個方法內。當你一想到作為參數的匿名類別實例，你也許想到對某個List的元素進行相同動作的程式碼。

List<Integer> numbers = asList(1, 2, 3);

List<Integer> multipliedWith2 = new ArrayList<>(); for (Integer number : numbers) { multipliedWith2.add(number * 2); }

常常要對List內的所有元素做同一件事，因此你可以寫個這樣的方法來幫忙：

interface Mapper<P, R> { R apply(P p); } static <T, R> List<R> map(List<T> lt, Mapper<T, R> mapper) { List<R> mapped = new ArrayList<>(); for (T elem : lt) { mapped.add(mapper.apply(elem)); } return mapped; }

現在你可以將上面的東西寫成：

Mapper<Integer, Integer> multiply2 = new Mapper<Integer, Integer>() { public Integer apply(Integer number) { return number * 2; } }; List<Integer> multipliedBy2 = map(numbers, multiply2);

另一個常見的工作是將List內的所有元素按某種方法合起來：

static Integer sum(List<Integer> numbers) { Integer sum = 0; for (Integer number : numbers) { sum += number; } return sum; } static String join(List<String> strs) { String joined = ""; for (String str : strs) { joined += str; } return joined; } println(sum(asList(1, 2, 3))); println(join(asList("a","b","c")));

sum和join長得很像，你也許想將它們抽象化，變成將List內所有元素按某種方法合起來的泛型方法：

interface Reducer<R, P> { R apply(R r, P p); } static <T, R> R reduce(List<T> lt, Reducer<R, T> reducer, R init) { R r = init; for(T elem : lt) { r = reducer.apply(r, elem); } return r; } static Integer sum(List<Integer> numbers) { Reducer<Integer, Integer> sumUp = new Reducer<Integer, Integer>() { public Integer apply(Integer sum, Integer number) { return sum + number; } }; return reduce(numbers, sumUp, 0); } static String join(List<String> strs) { Reducer<String, String> joinAll = new Reducer<String, String>() { public String apply(String all, String str) { return all + str; } }; return reduce(strs, joinAll, ""); }

如果用JavaScript之類具有一級函式的語言，可以更簡單地作這這些事。許多較舊的語言沒法子做這種事。有些語言容許你做，不過困難重重（例如C有函數指標，但你要在別處宣告和定義函數）。而物件導向語言則認為不應該容許使用函數，像是這邊示範的Java。如果你想將函數視為第一類物件，Java要求你建立一個有單方法的物件，稱之為Functor。另外許多物件導向語言要求你為類別建立個別檔案，結果變得不怎麼快(klunky fast）。如果你的編程語言要求使用Functor，就不能徹底得到現代編程環境的好處。看看你可否退貨拿回些錢。那麼使用具有一級函式的語言，你就能寫出來嗎？沒有一級函式是麻煩了些，但重點在於有沒有以上不斷思考的過程。嗯？不過就是寫出那些僅僅只是對List中每個元素做事的小小方法，究竟能得到多少好處？讓我們回到map函數。對List內的每個元素做事時，很可能並不在乎哪個元素先做。無論由第一個還是最後一個元素開始，結果都是一樣的，對不對？如果你手頭上有2個CPU，就可以寫段程式碼，使得它們各對一半的元素工作，於是map就變快兩倍了。或者你在全球有千千百百台伺服器(只是假設)，還有一個很大很大的List，存放整個互聯網的內容(同樣也只是假設)。現在你可以在這些伺服器上執行map，讓各台伺服器只處理問題很小的一部份。所以現在可以再舉個例子，要寫出能超快速搜尋整個互聯網的程式碼其實很簡單，只要呼叫一個以基本字串搜尋器作為參數的map方法即可。這裡頭有件真正有趣的事值得注意：當你把map和reduce想成每個人都能用的方法，而大家也都在用，只要有個超級天才，寫出能在全球巨型平行電腦陣列上執行map和reduce的程式碼，那麼所有原本用單一迴圈能正常運行的舊程式碼，還是照樣能用，但是卻會快上千萬倍，也就是說可以用來在瞬間解決掉巨大的問題。 Lemme重覆了這一點。它把迴圈的基本概念抽象出來，你可以用任何所要的方式實作迴圈，其中包括能適切地配合額外硬體的實作方式。你現在明白我想問的是：你是不是那種沒有一級函式就什麼都寫不了的程式設計師？不了解函數式程式設計（Functional programming）就無法發明MapReduce這個讓Google延展性如此強大的演算法。Map和Reduce這個術語源自Lisp和函數式程式設計。回想起來，對瞭解函數式程式設計的人來說，MapReduce實在是很明顯的事情，純粹的函數式程式沒有副作用，所以能輕易地平行化。我希望你現在明白，確實地，有第一級函數的編程語言讓你找到更多抽象化的機會，也就是說你程式碼會更小、更緊密，不過就算沒有一級函式，你還是可以具有相同的想法，撰寫出便於再用而且延展性更佳的程式。無數的Google應用軟體使用MapReduce，因此一有人改進其效率或修正臭蟲，這些應用軟體都得益了。每次我都會有點疑惑，在具有生產效益的編程環境，確實能讓你更容易在不同的抽象層次作業的環境。老掉牙的GW-BASIC不讓你寫函數。C有函數指標，但是醜陋之極又不許匿名，一定得在其他地方實作，不能直接寫在使用的地方。Java則是讓你使用Functor這個更醜陋的東西。正如Steve Yegge所述，Java是個名詞王國。那又如何？C語言就寫不出具有物件導向概念的程式碼？有了一級函式這樣的利器，你的等級就自然提昇？JDK8後會有Lambda了，如果你在先前的JDK 版本，就懂得在程式中作以上的處理，那你就更能從JDK8的Lambda中獲益：

static Integer sum(List<Integer> numbers) { return reduce(numbers, (sum, number) -> sum + number, 0); } static String join(List<String> strs) { return reduce(strs, (all, str) -> all + str, ""); }

你的腦袋沒辦法這樣想的話，最有可能的是，只會將JDK8的Lambda當作匿名類別的語法蜜糖罷了，也沒道理用了一級函式的動態語言，腦袋就會自動昇級。別忘了有多少用Java寫的程式碼，一點都不物件導向。

商业用途请联系作者获得授权。
版权声明：本文为博主「任霏」原创文章，遵循 CC BY-NC-SA 4.0 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.renfei.net/posts/1000018

你的腦袋可以這樣想嗎？

相关推荐