Golang 函數(shù)式編程基礎(chǔ)

作者：DeepNoMind 2025-03-11 10:00:20

本文主要介紹如何在 Golang 中實(shí)現(xiàn)函數(shù)式編程的基礎(chǔ)概念和技巧，詳細(xì)闡述了函數(shù)式編程的多個(gè)關(guān)鍵概念，并通過代碼示例展示如何在 Go 中實(shí)現(xiàn)。

當(dāng)聽到 "函數(shù)式編程" 時(shí)，Go 并不是你會(huì)首先想到的語言。你可能會(huì)想到 Haskell，它有純函數(shù)和單子（先別慌），或者 JavaScript，它喜歡用高階函數(shù)和回調(diào)來炫耀。但你也可以用 Go 進(jìn)行函數(shù)式編程，而且一點(diǎn)也不枯燥無聊。

高階函數(shù)（Higher-Order Functions）

首先，我們來談?wù)劯唠A函數(shù)。這些函數(shù)可以與其他函數(shù)很好的配合，要么將它們作為參數(shù)，要么將它們作為返回值。在 Go 的世界里，這不僅是可能的，而且是非常巧妙的。

package main

import (
"fmt"
)

func filter(numbers []int, f func(int) bool) []int {
var result []int
for _, value := range numbers {
if f(value) {
   result = append(result, value)
  }
 }
return result
}

func isEven(n int) bool {
return n%2 == 0
}

func main() {
 numbers := []int{1, 2, 3, 4}
 even := filter(numbers, isEven)
 fmt.Println(even) // [2, 4]
}

你看到了嗎？我們好像在用一個(gè)更快的 JavaScript。

柯里化（Currying）

接下來是柯里化，這是將一個(gè)接收多個(gè)參數(shù)的函數(shù)分解成一系列各接收一個(gè)參數(shù)的函數(shù)。它實(shí)際上沒有想象的那么復(fù)雜。

package main

import"fmt"

func add(a int) func(int) int {
returnfunc(b int) int {
return a + b
 }
}

func main() {
 addFive := add(5)
 fmt.Println(addFive(3)) // 8
}

簡單、直接，無需任何修飾即可完成工作。

不變性（Immutability）

函數(shù)式編程的特點(diǎn)之一是不變性。一旦構(gòu)造了某樣?xùn)|西，就不會(huì)再改變。相反，如果你需要不同的東西，可以構(gòu)建一個(gè)新的。這乍聽起來可能有點(diǎn)浪費(fèi)，但實(shí)際上卻能保持整潔并減少副作用。

package main

import "fmt"

func main() {
 obj := map[string]int{"a": 1, "b": 2}
 newObj := make(map[string]int)
 for k, v := range obj {
  newObj[k] = v
 }
 newObj["b"] = 3
 fmt.Println(newObj) // map[a:1 b:3]
}

純函數(shù)（Pure Functions）

純函數(shù)就像是個(gè)愛干凈的朋友，不會(huì)接觸或修改其范圍之外的任何東西。你所傳入的就是你所使用的，你所返回的就是它們唯一的效果。

package main

import "fmt"

func square(x int) int {
 return x * x
}

func main() {
 fmt.Println(square(5)) // 25
}

看，沒有副作用。在創(chuàng)建這個(gè)函數(shù)的過程中，沒有破壞任何全局變量。

算子（Functors）

用最淺顯易懂的話來說，算子就是任何可以映射函數(shù)的東西。想想不起眼的數(shù)組，對(duì)每一項(xiàng)應(yīng)用一個(gè)函數(shù)，然后得到一個(gè)新數(shù)組。在 Go 中，沒有內(nèi)置的通用 map 函數(shù)，但我們可以自己構(gòu)建。

讓定義一個(gè)操作 int 切片的算子：

package main

import"fmt"

// Functor on a slice of int
func mapInts(values []int, f func(int) int) []int {
 result := make([]int, len(values))
for i, v := range values {
  result[i] = f(v)
 }
return result
}

func main() {
 numbers := []int{1, 2, 3, 4}
 squared := mapInts(numbers, func(x int) int { return x * x })
 fmt.Println(squared) // [1, 4, 9, 16]
}

看看這個(gè)！有了這樣的編碼技巧，誰還需要內(nèi)置方法呢？

自映射算子（Endofunctors）

現(xiàn)在，我們來談?wù)勛杂成渌阕?，這只是一種花哨的說法，意思是一種將類型映射到相同類型的算子。簡單來說，從一個(gè) Go 切片開始，最終也會(huì)得到一個(gè)同樣類型的 Go 切片。這不是什么高科技，只是類型一致性的問題。

以之前的 mapInts 為例，這是一個(gè)變相的自映射算子。它接收 []int 并返回 []int，沒有類型轉(zhuǎn)換。

單態(tài)（Monoids）

想象一下，在一個(gè)聚會(huì)上，每個(gè)人都需要帶一個(gè)朋友。單子就像這樣，不過代表的是類型。它們需要兩樣?xùn)|西：一個(gè)結(jié)合兩種類型的操作和一個(gè)特殊值，后者就像最討人喜歡的朋友 -- 它與每個(gè)人都相處融洽，卻不會(huì)改變他們的任何東西。

在 Go 中，可以通過切片或數(shù)字看到這一點(diǎn)。我們以數(shù)字為例，因?yàn)閿?shù)字更容易上手：

package main

import"fmt"

// Integer addition is a monoid with zero as the identity element
func add(a, b int) int {
return a + b
}

func main() {
 fmt.Println(add(5, 5))  // 10
 fmt.Println(add(5, 0))  // 5
 fmt.Println(add(0, 0))  // 0
}

在這里，0 是我們的英雄，是身份元素，它讓數(shù)字保持不變。

單子（Monads）

單子是自映射算子類別中的一個(gè)單態(tài)。

當(dāng)有人拋出 "單子是子映射算子類別中的一個(gè)單態(tài)" 這樣的話語時(shí)，他們基本上是在炫耀自己的計(jì)算機(jī)科學(xué)詞匯量。詳細(xì)解釋一下：單子（monad）是一種編程結(jié)構(gòu)，以超級(jí)特殊的方式處理類型和函數(shù) -- 就像有些人對(duì)咖啡的沖泡方式很挑剔一樣。用最簡單的話來說，單態(tài)（monoid）就是用一種特殊的規(guī)則將各種東西組合在一起，其中包括一個(gè)無用元素或身份元素。現(xiàn)在，再加上子映射算子（endofunctors），就像普通的老式函數(shù)一樣，但它們堅(jiān)持在自己的小宇宙（范疇）內(nèi)變換事物。把這一切放在一起，你就會(huì)明白，單子可以被看作是將函數(shù)按序列粘連在一起的一種方式，只不過是以一種超級(jí)自足的方式，同時(shí)也尊重?cái)?shù)據(jù)的原始結(jié)構(gòu)。這就像在說："我們要去公路旅行，但只能走風(fēng)景優(yōu)美的小路，最后我們還是會(huì)回到起點(diǎn)"。

單子是萬事通，不僅可以處理帶有上下文的值（如錯(cuò)誤或列表），還可以通過傳遞上下文的方式將操作鏈在一起。在 Go 中，要模仿這一點(diǎn)可能有點(diǎn)困難，但讓我們來看看錯(cuò)誤處理，這也是單子的實(shí)際用途。

package main

import (
"errors"
"fmt"
)

// Maybe represents a monad for error handling
func Maybe(value int, err error, f func(int) (int, error)) (int, error) {
if err != nil {
return0, err
 }
return f(value)
}

func main() {
// Simulate a computation that might fail
 process := func(v int) (int, error) {
if v < 0 {
   return0, errors.New("negative value")
  }
return v * v, nil
 }

// Use our Maybe "monad" to handle potential errors
 result, err := Maybe(5, nil, process)
if err != nil {
  fmt.Println("Error:", err)
 } else {
  fmt.Println("Success:", result) // Success: 25
 }
}

這個(gè)臨時(shí)單子可以幫助我們處理可能出錯(cuò)的計(jì)算，而不會(huì)在代碼中造成恐慌和混亂。