函數式編程雜談

  • 2019 年 10 月 3 日
  • 筆記

本文首發於 vivo互聯網技術 微信公眾號 
鏈接：https://mp.weixin.qq.com/s/gqw57pBYB4VRGKmNlkAODg
作者：張文博

比起命令式編程，函數式編程更加強調程式執行的結果而非執行的過程，倡導利用若干簡單的執行單元讓計算結果不斷演進，逐層推導出複雜的運算。本文通過函數式編程的一些趣味用法來闡述學習函數式編程的奇妙之處。

一、編程範式綜述

編程是為了解決問題，而解決問題可以有多種視角和思路，其中普適且行之有效的模式被歸結為“編程範式”。程式語言日新月異，從彙編、Pascal、C、C++、Ruby、Python、JS，etc…其背後的編程範式其實並沒有發生太多變化。拋開各語言繁紛複雜的表象去探究其背後抽象的編程範式可以幫助我們更好地使用computer進行compute。

1.命令式

電腦本質上是執行一個個指令，因此編程人員只需要一步步寫下需要執行的指令，比如：先算什麼再算什麼，怎麼輸入怎麼計算怎麼輸出。所以程式語言大多都具備這四種類型的語句：

  1. 運算語句將結果存入存儲器中以便日後使用；

  2. 循環語句使得一些語句可以被反覆運行；

  3. 條件分支語句允許僅當某些條件成立時才運行某個指令集合；

  4. 以及存有爭議的類似goto這樣的無條件分支語句。

使得執行順序能夠轉移到其他指令之處。

無論使用彙編、C、Java、JS 都可以寫出這樣的指令集合，其主要思想是關注電腦執行的步驟，即一步一步告訴電腦先做什麼再做什麼。所以命令式語言特別適合解決線性的計算場景，它強調自上而下的設計方式。這種方式非常類似我們的工作、生活，因為我們的日常活動都是按部就班的順序進行的，甚至你可以認為是面向過程的。也比較貼合我們的思維方式，因此我們寫出的絕大多數程式碼都是這樣的。

2.聲明式

聲明式編程是以數據結構的形式來表達程式執行的邏輯，它的主要思想是告訴電腦應該做什麼，但不指定具體要怎麼做（當然在一些場景中，我們也還是要指定、探究其如何做）。SQL 語句就是最明顯的一種聲明式編程的例子，例如：“SELECT * FROM student WHERE age> 18”。因為我們歸納剝離了how，我們就可以專註於what，讓資料庫來幫我們執行、優化how。

有時候對於某個業務邏輯目前沒有任何可以歸納提取的通用實現，我們只能寫命令式編程程式碼。當我們寫成以後，如果進行思考歸納抽象、進一步優化，就為以後的聲明式做下鋪墊。

通過對比，命令式編程模擬電腦運算，是行動導向的，關鍵在於定義解法，即“怎麼做”，因而演算法是顯性而目標是隱性的；聲明式編程模擬人腦思維，是目標驅動的，關鍵在於描述問題，即“做什麼”，因而目標是顯性而演算法是隱性的。

3.函數式

函數式編程將電腦運算視為函數運算，並且避免使用程式狀態以及易變對象。這裡的“函數”不是指電腦中的函數，而是指數學中的函數，即自變數的映射。也就是說一個函數的值僅決定於函數參數的值，不依賴其他狀態。比如f(x)，只要x不變，不論什麼時候調用，調用幾次，值都是不變的。比起命令式編程，函數式編程更加強調程式執行的結果而非執行的過程，倡導利用若干簡單的執行單元讓計算結果不斷演進，逐層推導出複雜的運算，而不是設計一個複雜的執行過程。函數作為一等公民，可以出現在任何地方，比如你可以把函數作為參數傳遞給另一個函數、還可以將函數作為返回值。

函數式編程的特點：

  1. 減少了可變數的聲明，程式更為安全；

  2. 相比命令式編程，少了非常多的狀態變數的聲明與維護，天然適合高並發多執行緒並行計算等任務，我想這也是函數是編程近年又大熱的重要原因之一；

  3. 程式碼更為簡潔，但是可讀性是高是低也依賴於不同場景、仁者見仁智者見智。

二、函數式編程的一些趣味用法

1.Closure(閉包)

public class OutClass {      private void helloWorld() {      System.out.println("Hello World!");    }      public InnerClass getInnerClass() {      return new InnerClass();    }      public class InnerClass {      public void hello() {        helloWorld();      }    }      /**     * @param args     */    public static void main(String[] args) {      // 在外部使用OutClass的private方法      new OutClass().getInnerClass().hello();    }  }

在Java中有很多方式實現上述目的，因為我們的作用域和JS有著巨大差異。但是借鑒閉包的原理，我們來看一個場景。假設介面A有一個方法m；介面B也有一個同名的方法m，兩個方法的簽名完全一樣但是功能卻不一樣。類C想要同時實現介面A和介面B中的方法。因為兩個介面中的方法簽名完全一致，所以C只能有一個m方法，這種情況下應該怎麼實現需求呢？

public class C implements A {      @Override    public void m() {      //...    }      private void o() {      //...    }      public D getD() {      return new D();    }      class D implements B {      @Override      public void m() {        o();      }    }      public static void main(String[] args) {        C c = new C();        c.m();        c.getD().m();    }  }

 

2.Currying(柯里化)

我對柯里化(Currying)的理解：柯里化函數可以接收一些參數，接收了這些參數之後，該函數並不是立即求值，而是繼續返回另一個函數，剛才傳入的參數在函數形成的閉包中被保存起來，待到函數真正需要求值的時候，之前傳入的所有參數都能用於求值。

下面先通過JS（個人感覺通過JS比較好理解）對柯里化有一個直觀的認識。

 
 
 
var calculator = function(x, y, z){      return(x + y)* z;  }

 

調用：calculator( 2, 7, 3);

柯里化寫法：

var calculator=function(x){    return function(y){      return function(z){        return(x + y)* z;      };    };  };

調用：calculator(2)(7)(3);

通過對比，我們發現柯里化的數學描述應該類似這樣，calculator(2, 7, 3) —> calculator(2)(7)(3)。

現在我們來回頭看看柯里化較為學術的定義，是把接受多個參數的函數變換成接受一個單一參數的函數，並且返回接受餘下的參數的新函數，這個新函數最後還能返回所有輸入的運算結果。

Java 中的柯里化實現

Function<Integer, Function<Integer, Function<Integer, Integer>>> currying =      new Function<Integer, Function<Integer, Function<Integer, Integer>>>() {        @Override      public Function<Integer, Function<Integer, Integer>> apply(Integer x) {          return new Function<Integer, Function<Integer, Integer>>() {                @Override              public Function<Integer, Integer> apply(Integer y) {                    return new Function<Integer, Integer>() {                      @Override                      public Integer apply(Integer z) {                          return (x + y) * z;                      }                  };              }          };      }  };    //在這裡，我們可以發現，雖然依次輸入2、7，但是我們並不會計算結果，而是等到最後輸入結束時才會返回值。  Function function1 = curryingFun().apply(2);//返回的是函數  Function function2 = curryingFun().apply(2).apply(7);//返回的是函數  Integer value = curryingFun().apply(2).apply(7).apply(3);//參數全部輸入，返回最後的值

柯里化的爭論

（1）支援的觀點

  • 延遲計算，只有在最後的輸入結束才會進行計算;

  • 當你發現你要調用一個函數，並且調用參數都是一樣的情況下，這個參數就可以被柯里化，以便更好的完成任務;

  • 優雅的寫法，語義更有表達力;

（2）不過也有一些人持反對觀點，參數的不確定性、排查錯誤困難。

3.Promise

Promise 是非同步編程的一種解決方案，比傳統的諸如“回調函數、事件”解決方案，更合理和更強大。ES6已經廣泛應用。我在這裡主要分析兩個最常見的用法。

  • then

Promise實例生成以後，可以用then方法分別指定resolved狀態和rejected狀態的回調函數。then方法返回的是一個新的Promise實例（注意，不是原來那個Promise實例）。因此可以採用鏈式寫法，即then方法後面再調用另一個then方法。

promise.then(function(value) {   // success  }, function(error) {   // failure  }).then(...);

 
  • all

Promise.all方法用於將多個 Promise 實例，包裝成一個新的 Promise 實例。

const p = Promise.all([p1, p2, p3]);

　　

上面程式碼中，Promise.all方法接受一個數組作為參數，p1、p2、p3都是 Promise 實例，p的狀態由p1、p2、p3決定，分成兩種情況。

  • 只有p1、p2、p3的狀態都變成fulfilled，p的狀態才會變成fulfilled，此時p1、p2、p3的返回值組成一個數組，傳遞給p的回調函數。

  • 只要p1、p2、p3之中有一個被rejected，p的狀態就變成rejected，此時第一個被reject的實例的返回值，會傳遞給p的回調函數。

下面是一個具體的例子：

// 生成一個Promise對象的數組  const promises = [1,2,3.....].map(function (id) {    return getJSON('/post/' + id + ".json");  });    Promise.all(promises).then(function (posts) {    // ...  }).catch(function(reason){     // ...  });

 

Java的實現

Java中的使用方法目前確實不如js方便，可以看看CompletableFuture，給我們提供了一些方法。

4.Partial Function

其定義如下：當函數的參數個數太多，可以創建一個新的函數，這個新函數可以固定住原函數的部分參數，從而在調用時更簡單。下面是基於Python的實現。個人覺得，最大的便利就是避免我們再去寫一些重載的方法。不過暫時沒有看到partial的Java版本。看到這裡，大家肯定認為“偏函數”這個翻譯實在是不準確，如果直譯過來叫“部分函數”好像也不怎麼清晰，我們姑且還是稱其為Partial Function。

# !/usr/bin/python  # -*- coding: UTF-8 -*-  from functools import partial  def multiply(x, y):    return x * y  print(multiply(3,4))# 輸出12    multiply4 = partial(multiply, y =4)# 不需要定義重載函數  print(multiply4(3))# 輸出12

 

5.map/reduce

Java現在對map、reduce也做了支援，特別是map已經是大家日常編碼的利器，相信大家也都不陌生了。map（flatMap）按照規則轉換輸入內容，而reduce則是通過某個連接動作將所有元素匯總的操作。但是在這裡我還是使用Python的例子來進行闡述，因為我覺得Python看起來更簡潔明了。

# !/usr/bin/python  # -*- coding: UTF-8 -*-  from functools import reduce    def addTen(x):      return x + 10    def add(x, y):      return x + y    r = map(addTen, [1, 2, 3, 4, 5, 6, 7, 8, 9])  print r  #[11, 12, 13, 14, 15, 16, 17, 18, 19]  total = reduce(add, r)  print total #[11, 12, 13, 14, 15, 16, 17, 18, 19]加和等於135

6.divmod

divmod是Python的函數，我之所以專門來講述，是因為它所代表的思想確實新穎。函數會把除數和餘數運算結果結合起來返回，如下。不過Java肯定不支援。

//把秒數轉換成時分秒結構顯示  def parseDuration( seconds ):      m, s = divmod(int(seconds), 60)      h, m = divmod(m, 60)      return  ("%02d:%02d:%02d" % (h, m, s))

三、關於Scala

上述很多特性，Scala都提供了支援，它集成了面向對象編程和函數式編程的一些特性，感興趣的同學可以了解一下。之前看過介紹，Twitter對於Scala的應用比較多，推薦閱讀 Twitter Effective Scala 。

四、結語：我們為什麼要學習函數式編程

在很多時候，無可否認命令式編程很好用。當我們寫業務邏輯時會書寫大量的命令式程式碼，甚至在很多時候並沒有可以歸納抽離的實現。但是，如果我們花時間去學習、發現可以歸納抽離的部分使其朝著聲明式邁進，結合函數式的思維來思考，能為我們的編程帶來巨大的便捷。

通過其他語言來觸類旁通函數式編程的奇技淫巧，確實能帶給我們新的視野。我相信隨著機器運算能力不斷提升、底層能力更加完善，我們也需要跳出如何做的思維限制，更多地站在更高的抽象層去思考做什麼，方能進入一個充滿想像、神奇的computable world。

更多內容敬請關注 vivo 互聯網技術 微信公眾號

註：轉載文章請先與微訊號：labs2020 聯繫。

VirMach 便宜 VPS

QNews

QNews