go 學習筆記之學習函數式編程前不要忘了函數基礎

在編程世界中向來就沒有一家獨大的編程風格,至少目前仍是百家爭鳴的春秋戰國,除了衆所周知的面向對象編程還有日漸流行的函數式編程,固然這也是本系列文章的重點.

愈來愈多的主流語言在設計的時候幾乎無一例外都會參考函數式特性( lambda 表達式,原生支持 map,reduce...）,就連面嚮對象語言的 Java8 也慢慢開始支持函數式編程,因此再不學習函數式編程可能就晚了!

可是在正式學習函數式編程以前,不妨和早已熟悉的面向對象編程心底裏作下對比,經過對比學習的方式,相信你必定會收穫滿滿,所以特意整理出來關於 Go 語言的面向對象系列文章,邀君共賞.

• go 學習筆記之go是否是面嚮對象語言是否支持面對對象編程?
• go 學習筆記之詳細說一說封裝是怎麼回事
• go 學習筆記之是否支持以及如何實現繼承
• go 學習筆記之萬萬沒想到寵物店居然催生出面向接口編程?
• go 學習筆記之無意插柳柳成蔭的接口和無爲而治的空接口

上述系列文章講解了 Go 語言面向對象相關知識點,若是點擊後沒有自動跳轉,能夠關注微信公衆號「雪之夢技術驛站」查看歷史文章,再次感謝你的閱讀與關注.

生物學家和數學家的立場不一樣

雖然是同一個世界,可是不一樣的人站在各自立場看問題,結果天然會千人千面,各有不一樣.

生物學家會下意識對動植物進行分類概括,面向對象編程也是如此,用一系列的抽象模型去模擬現實世界的行爲規律.

數學家向來以嚴謹求學著稱,做爲最重要的基礎科學,數學規律以及概括演繹方法論對應的就是函數式編程,不是模擬現實而是描述規律更有可能創造規律.

標準的函數式編程具備濃厚的數學色彩,幸運的是,Go 並非函數式語言,因此也沒必要受限於近乎苛責般的條條框框.

簡單來講,函數式編程具備如下特色:

• 不可變性: 不用狀態變量和可變對象
• 函數只能有一個參數
• 純函數沒有反作用

摘自維基百科中關於函數式編程中有這麼一段話:

In computer science, functional programming is a programming paradigm—a style of building the structure and elements of computer programs—that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

上述的英文的大體意思是說:函數式編程將計算機程序當作是數學函數的推演,不用狀態變量也不用可變對象來表達數與數之間的關係.

如需瞭解詳情,可點擊訪問維基百科關於函數式編程 Functional programming 的相關介紹.

函數式編程的立足點和出發點是函數,複雜函數是基本函數通過必定組合規律造成的,因此描述複雜函數的過程就是如何拆解重組的過程.

因此接下來咱們一邊複習一邊學習函數的基本特色,爲接下來理解函數式編程打下基礎,關於函數的基礎語言可參考 go 學習筆記之值得特別關注的基礎語法有哪些

函數的基礎語法和高級特性

下面以最基本四則運算爲例,貫穿全文講解函數的基本語法和高級特性,力求作到知其然知其因此然.

• func 定義普通函數

eval 函數定義了加減乘除基本運算規則,若不支持操做類型則拋出異常,終止程序.

func eval(a, b int, op string) int {
    var result int
    switch op {
    case "+":
        result = a + b
    case "-":
        result = a - b
    case "*":
        result = a * b
    case "/":
        result = a / b
    default:
        panic("unsupported operator: " + op)
    }
    return result
}

測試未定義操做取餘 % 運算時,則拋出異常,unsupported operator: % ,說明僅僅支持加減乘除基本運算.

func TestEval(t *testing.T) {
    // 3 -1 2 0 unsupported operator: %
    t.Log(
        eval(1, 2, "+"),
        eval(1, 2, "-"),
        eval(1, 2, "*"),
        eval(1, 2, "/"),
        eval(1, 2, "%"),
    )
}

• 多返回值定義標準函數

Go 語言和其餘主流的編程語言明顯不一樣的是,函數支持多返回值,一般第一個返回值表示真正結果,第二個返回值表示是否錯誤,這也是 Go 關於異常錯誤設計的獨特之處.

若是正常返回,則表示沒有錯誤,那麼第一個返回值是正常結果而第二個返回值則是空 nil;若是異常返回,第一個返回值設計無心義的特殊值,第二個返回值是具體的錯誤信息,通常非 nil.

func evalWithStandardStyle(a, b int, op string) (int, error) {
    switch op {
    case "+":
        return a + b, nil
    case "-":
        return a - b, nil
    case "*":
        return a * b, nil
    case "/":
        return a / b, nil
    default:
        return 0, fmt.Errorf("unsupported operator: %s", op)
    }
}

改造 eval 函數以編寫真正 Go 程序,此時再次測試,結果顯示遇到沒有定義的操做符時再也不拋出異常而是返回默認零值以及給出簡短的錯誤描述信息.

func TestEvalWithStandardStyle(t *testing.T) {
    // Success: 2
    if result, err := evalWithStandardStyle(5, 2, "/"); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }

    // Error: unsupported operator: %
    if result, err := evalWithStandardStyle(5, 2, "%"); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }
}

• 其餘函數做爲參數傳入

上例經過多返回值解決了遇到不支持的運算符會報錯終止程序的問題,可是並無真正解決問題,假如真的想要進行非預約義的運算時,一樣是無能爲力!

誰讓你只是使用者而不是設計者呢!

那麼舞臺交給你,你就是主角,你想要怎麼處理輸入怎麼輸出就怎麼處理,所有邏輯轉移給使用者,這樣就不存在沒法知足需求的狀況了.

func evalWithApplyStyle(a, b int, op func(int, int) (int, error)) (int, error) {
    return op(a, b)
}

操做符由原來的字符串 string 更改爲函數 func(int, int) (int, error),舞臺交給你,全靠自由發揮!

evalWithApplyStyle 函數內部直接調用函數參數 op 並返回該函數的處理結果,當前演示示例中函數的控制權徹底轉移給函數入參 op 函數,實際狀況可按照實際需求決定如何處理 evalWithApplyStyle 邏輯.

func divide(a, b int) (int, error) {
    return a / b, nil
}

func mod(a, b int) (int, error) {
    return a % b, nil
}

本身動手,豐衣足食,順手定義除法 divide 和取餘 mod 運算,接下來測試下實現效果.

func TestEvalWithApplyStyle(t *testing.T) {
    // Success: 2
    if result, err := evalWithApplyStyle(5, 2, divide); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }

    // Success: 1
    if result, err := evalWithApplyStyle(5, 2, mod); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }
}

測試結果很理想,不只實現了減加乘除等基本運算,還能夠實現以前一直無法實現的取餘運算!

這說明了這種函數做爲參數的作法充分調動勞動人民積極性,媽媽不再用擔憂我沒法實現複雜功能了呢!

• 匿名函數也能夠做爲參數

通常而言,調用函數時都是直接用函數名進行調用,單獨的函數具備可複用性,但若是本就是一次性函數的話,實際上是不必定義帶函數名形式的函數.

依然是上述例子,這一次對兩個數的運算規則再也不是數學運算了,這一次咱們來比較兩個數的最大值,使用匿名函數的形式進行實現.

func TestEvalWithApplyStyle(t *testing.T) {
    // Success: 5
    if result, err := evalWithApplyStyle(5, 2, func(a int, b int) (result int, e error) {
        if a > b {
            return a, nil
        }
        return b, nil
    }); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }
}

• 函數的返回值能夠是函數

依然是上述示例,若是因爲緣由不須要當即返回函數的計算結果而是等待使用者本身以爲時機合適的時候再計算返回值,這時候函數返回值依然是函數就頗有做用了,也就是所謂的惰性求值.

func evalWithFunctionalStyle(a, b int, op func(int, int) (int, error)) func() (int, error) {
    return func() (int, error) {
        return op(a, b)
    }
}

上述函數看起來可能有點難以理解,實際上相對於上例僅僅更改了返回值,由原來的 (int, error) 更改爲 func() (int, error) ,其他均保持不變喲!

evalWithFunctionalStyle 函數依然是使用者的主場,和上例相比的惟一不一樣之處在於,你的主場你作主,何時裁判徹底本身說了算,並非運行後就立馬宣佈結果.

func pow(a, b int) (int, error) {
    return int(math.Pow(float64(a), float64(b))),nil
}

func TestEvalWithFunctionalStyle(t *testing.T) {
    ef := evalWithFunctionalStyle(5, 2, pow)

    time.Sleep(time.Second * 1)

    // Success: 25
    if result, err := ef(); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }
}

time.Sleep(time.Second * 1) 演示代碼表明執行 evalWithFunctionalStyle 函數後能夠不當即計算最終結果,等待時機合適後由使用者再次調用 ef() 函數進行惰性求值.

// 1 1 2 3 5 8 13 21 34 55
//     a b
//       a b
func fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

• 函數能夠充當類型

上述示例中講解了函數能夠做爲返回值,參數有函數,返回值也有參數,因此 evalWithFunctionalStyle 函數看起來比較費勁,而 Go 語言的類型別名就是爲了簡化而生的,更況且函數是 Go 中的一等公民,固然也適合了.

func evalWithFunctionalStyle(a, b int, op func(int, int) (int, error)) func() (int, error) {
    return func() (int, error) {
        return op(a, b)
    }
}

因而打算把入參函數 func(int, int) (int, error) 和返回值函數 func() (int, error) 進行統一,而入參函數和返回值函數惟一不一樣之處就是入參個數不一樣,因此瓜熟蒂落想到了 Go 函數中的不定長參數相關語法.

type generateIntFunc func(base ...int) (int, error)

這樣入參函數和出參函數均可以用 generateIntFunc 類型函數進行替代,接着改造 evalWithFunctionalStyle 函數.

func evalWithObjectiveStyle(a, b int, op generateIntFunc) generateIntFunc {
    return func(base ...int) (i int, e error) {
        return op(a, b)
    }
}

改造後的 evalWithObjectiveStyle 函數看起來比較簡潔,花花架子中看是否中用還很差說,仍是用測試用例說話吧!

func TestEvalWithObjectiveStyle(t *testing.T) {
    ef := evalWithObjectiveStyle(5, 2, func(base ...int) (int,error) {
        result := 0
        for i := range base {
            result += base[i]
        }
        return result,nil
    })

    time.Sleep(time.Second * 1)

    // Success: 7
    if result, err := ef(); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }
}

函數別名進行類型化後並不影響功能,依然是函數式編程,不過夾雜了些面向對象的味道.

• 類型化函數能夠實現接口

函數經過別名形式進行類型化後能夠實現接口,某些程度上能夠視爲一種類型,所以實現接口也是瓜熟蒂落的事情.

func (g generateIntFunc) String() string {
    r,_ := g()
    return fmt.Sprint(r)
}

此處示例代碼中爲類型化函數 generateIntFunc 實現 String 接口方法,可能並無太大實際意義,僅僅是爲了講解這個知識點而硬湊上去的,實際狀況確定會有所不一樣.

func TestEvalWithInterfaceStyle(t *testing.T) {
    ef := evalWithObjectiveStyle(5, 2, func(base ...int) (int,error) {
        result := 0
        for i := range base {
            result += base[i]
        }
        return result,nil
    })

    time.Sleep(time.Second * 1)

    // String: 7
    t.Log("String:", ef.String())

    // Success: 7
    if result, err := ef(); err != nil {
        t.Log("Error:", err)
    } else {
        t.Log("Success:", result)
    }
}

惰性求值獲取的函數變量 ef 此時能夠調用 String 方法,也就是具有對象化能力,獲得的最終結果居然和直接運行該函數的值同樣?

有點神奇,目前還不理解這是什麼操做,若是有 Go 語言的大佬們不吝賜教的話,小弟感激涕零!

• 水到渠成的閉包

函數的參數,返回值均可以是另外的函數,函數也能夠做爲引用那樣傳遞給變量,也存在匿名函數等簡化形式,除此以外,類型化後的函數還能夠用來實現接口等等特性應該足以闡釋一等公民的高貴身份地位了吧?

如此強大的函數特性,只要稍加組合使用就會擁有強大的能力,而且 Go 語言並非嚴格的函數式語言,沒有太多語法層面的限制.

// 1 1 2 3 5 8 13 21 34 55
//     a b
//       a b
func fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

斐波那契數列函數 fibonacci 的返回值是真正的生成器函數,每次調用都會生成新的斐波那契數字.

這就是 Go 語言實現閉包的一種簡單示例,fibonacci 函數自己的變量 a,b 被內部匿名函數 func() int 所引用,而這種引用最終被使用者不斷調用就會致使最初的 a,b 變量一直被佔用着,只要繼續調用這種生成器,裴波那契數列的數字就會一直遞增.

// 1 1 2 3 5 8 13 21 34 55
func TestFibonacci(t *testing.T) {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Print(f(), " ")
    }
    fmt.Println()
}

func TestFibonacci(t *testing.T) {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Print(f(), " ")
    }
    fmt.Println()
}

函數式編程入門函數總結

• 函數是一等公民,其中函數參數,變量,函數返回值均可以是函數.
• 高階函數是普通函數組合而成,參數和返回值能夠是另外的函數.
• 函數是函數式編程的基礎,支持函數式編程但並非函數式語言.
• 沒有純粹函數式編程的條條框框,更加靈活自由,良好的可讀性.

若是本文對你有所幫助,不用讚揚直接點贊就是最大的鼓勵,順便關注下微信公衆號「 雪之夢技術驛站 」那就更好啦!