函數式編程思惟在三行代碼情書中的應用

函數式編程概述

現在主流的編程語言，函數式編程範式或多或少都融入其中成了「標配」，或者說主流語言都在進行函數式方面的擴充，這是一個大趨勢。以Java爲例，隨着 Lambda塊 和 Stream API 等這種高階函數的加持，Java總算是裝備了函數式這一利器；博大精深的C++也在2011版的語言標準里加入了Lambda塊的支持；再好比前一段時間我初步體驗了的 Groovy語言，雖然其運行於JVM之上，然而其對 動態語言、函數式編程範式 以及 元編程功能 的加持所帶來的表現力和簡潔性能夠說甩了Java幾條街，能夠利用Groovy的全部動態功能構建高性能的JVM應用、將開發效率提升幾個數量級。語言的例子有不少，我不一一枚舉。

爲何要使用函數式編程範式

這裏講幾個函數式編程的典型特色，區別的對象那就是傳統的命令式編程

0x01. 更高層次的抽象（高階函數）
用高階抽象來取代基本的控制結構自己就是一個全新的思考方式，這樣可讓開發者聚焦精力於業務場景而無需費心複雜地層運做

舉個栗子：將一個字符串集合中的全部單詞轉爲大寫，咱們用Java語言來實現

若是按照傳統的命令式編程的解法，那接下來不出意外咱們得來寫循環、遍歷這種迭代操做了：

for (int i=0; i<wordList.size(); i++) {
   wordList.get(i).toUpperCase();
}

但若是使用Java的函數式編程範式，一切都是那麼的優雅，一句話搞定

wordList.stream.map( w -> w.toUpperCase() )

這裏的map()函數就是所謂的高階函數，咱們用高階函數代替了底層的迭代，由於咱們並無處理細節，咱們僅僅定義了映射的邏輯，迭代由高階函數來自動完成！

0x02. 提高代碼信噪比（簡潔性）
區別於面嚮對象語言用抽象來封裝不肯定因素，函數式編程經過儘可能減小不肯定因素來使代碼極度簡潔

上面的例子對於本條優勢的展示我想應該也沒必要多說了

0x03. 控制權轉交於運行時（動態性）
區別於傳統的編譯形語言，配備函數式編程範式的動態語言更多的將控制權轉交到語言運行時手裏，得到的則是更高的靈活性、表現力和性能權衡。

這三點優勢將在接下來的例子中切實的感覺並領會！

函數式編程例析

舉例1：詞頻統計
作的事情很簡單：給定一個單詞集合，統計出集合中除了助詞（如of、on、the等）以外的單詞出現的頻次，不區分大小寫

命令式解法： 至少分爲如下幾大步

• 先進行循環迭代
• 而後統一將單詞轉爲小寫
• 而後判斷單詞是不是助詞

• 最後進行詞頻統計

  public class WordCount {

  // 定義一個助詞集合，這些單詞不參與計數
     private Set<String> auxiliaryWordSet = new HashSet<String>() {{
        add("of"); add("the"); add("to"); add("and"); add("so"); add("are");
     }};
  
     // 傳統命令式解法實現的詞頻統計函數
     public Map doWordCount( List<String> context ) {
         Map<String,Integer> result = new HashMap<String, Integer>();
         for ( String word:context ) {  // 循環迭代
             String lowerCaseWord = word.toLowerCase();  // 將單詞統一轉換爲小寫
             if( !auxiliaryWordSet.contains(lowerCaseWord) ) {
                 if( null == result.get(lowerCaseWord) )
                     result.put( lowerCaseWord, 1 );
                 else
                     result.put( lowerCaseWord, result.get(lowerCaseWord)+1 );
             }
         }
         return result;
     }
  
     // main() 函數
     public static void main(String[] args) {
         List<String> wordList = new ArrayList<String>() {{
             add("The"); add("Products"); add("of"); add("Samsung"); add("and"); add("Apple");
             add("are"); add("so"); add("amazing"); add("especially"); add("Apple");
         }};
  
         WordCount wordCount = new WordCount();
         Map res = wordCount.doWordCount( wordList );
         System.out.print(res); // 打印：{apple=2, amazing=1, samsung=1, especially=1, products=1}
     }

  }

函數式解法：

若是咱們用Java的Stream API和Lambda塊所構成的函數式範式來重寫 doWordCount() 函數，一切都將如此簡潔：

public Map doWordCount2( List<String> context ) {
    Map<String,Integer> result = new HashMap<String, Integer>();
    context.stream().map( w -> w.toLowerCase() )
            .filter( w -> !auxiliaryWordSet.contains(w) )
            .forEach( w -> result.put( w, result.getOrDefault(w,0) + 1 ) );
    return result;
}

備註：這裏的getOrDefault是Java的Map提供的一個便利函數，意思是：在Map中若沒有找到給定的key時，返回一個「默認值」

對比命令式解法，用戶省去了不少繁瑣的迭代和判斷，咱們只講焦點聚焦在業務邏輯之上，代碼信噪比提高不小吧！

舉例2：連詞成句
給定一個離散的單詞集合，咱們想將字母數大於1的單詞的首字母大寫後，用 短橫線- 鏈接起來成爲一個句子

命令式解法：

public class WordConnect {

// 將單詞的首字母大寫
public String capitalizeFirstLetter( String s ) {
    return s.substring(0,1).toUpperCase() + s.substring(1,s.length() );
}

// 連詞成句
public String connectWord( List<String> context ) {
    StringBuilder result = new StringBuilder();
    for ( String word: context ) {
        if ( word.length() > 1 ) {
            result.append( capitalizeFirstLetter(word) );
            result.append("-");
        }
    }
    return result.substring(0,result.length()-1).toString();
}

// main()函數
public static void main(String[] args) {
    List<String> wordList = new ArrayList<String>() {{
        add("The"); add("Products"); add("of"); add("Samsung"); add("and"); add("Apple");
        add("are"); add("so"); add("amazing"); add("especially"); add("Apple");
    }};

    WordConnect wordConnect = new WordConnect();
    String res = wordConnect.connectWord( wordList );
    System.out.print(res); // 打印：The-Products-Of-Samsung-And-Apple-Are-So-Amazing-Especially-Apple
}

}

函數式解法1： Java Steam API 和 Lambda塊實現

public String connectWord( List<String> context ) {
    return context.stream().filter( w -> w.length()>1 )
            .map( w -> capitalizeFirstLetter(w) )
            .collect( Collectors.joining("-") );
}

我什麼都不想說了，這不要太簡潔好吧！

函數式解法2： Groovy語言實現

public String connectWord( context ) {
        context.findAll { it.length() >1 }
        .collect { it.capitalize() }
        .join '-'
    }

關於Groovy語言的初體驗，能夠參考個人文章：Groovy初體驗：構建高性能JVM應用

函數式最佳實踐：高效編寫三行情書
還記得去年的520，爲了表達心中對於老婆無限的、沒法表達的愛，我想寫一封不超過三行的代碼情書，我更想用盡量短的代碼來儘量多地表達，因而我選擇了函數式編程。

個人520三行代碼情書在此：

public TimeRiver timeFlow( List<DaysMeetYou> days ) {
    return (TimeRiver)days.stream()
        .filter( n->theDaysNotWithYou(n) )
        .map( e->accompanyByMyLove(e) )
        .collect( Collectors.joining("LOVE") );
}

個人520三行代碼情書

本文做者：codesheep

閱讀原文

本文爲雲棲社區原創內容，未經容許不得轉載