淺談用Go構建不可變的資料結構的方法

阿新 • • 發佈：2020-01-09

共享狀態是比較容易理解和使用的，但是可能產生隱晦以至於很難追蹤的 bugs。尤其是在我們的資料結構只有部分是通過引用傳遞的。切片就是這麼一個很好的例子。後續我會作出更加詳細的講解。

在處理經過多級變換或狀態的資料時，不可變資料結構是非常有用的。不可變僅意味著原始結構是不可以被改變的，而每一個新的結構副本都是以新的屬性值建立。

讓我們看個簡單的例子：

type Person struct {
  Name      string
  FavoriteColors []string
}

顯然，我們可以例項化一個Person然後隨心所欲地更改它的屬性。事實上，這樣做並沒有任何錯。但是，當你處理更加複雜的、傳遞引用和切片的巢狀式資料結構，或者利用通道傳遞副本時，以某些姿勢更改這些共享的資料副本可能會導致不易察覺的 bugs。

為啥我之前就沒有遇到過這種問題呢？

如果沒有重度使用 channel 或程式碼基本是序列執行的，由於從定義上講每次只有一個操作能夠作用在資料上，你不大可能會遇見這些不明顯的 bugs。

再者，除了避免 bugs外，不可變資料結構還有其他優勢：

由於狀態絕不會原地更新，這對一般的除錯和記錄每個變換步驟以用於後續監控是非常有用的
撤銷或“時光倒流”的能力不僅是可能的，而且是小菜一碟，只需一個賦值操作即可
由於正確且安全的實現需要損失效能和費盡心思地仔細設定/測試記憶體鎖，共享狀態被廣泛認為是糟糕的做法

Getter 和 Wither

Getter 返回資料，setter 改變資料，wither 建立新狀態。

基於 getter 和 wither，我們可以精準控制能被改變的屬性。這也為我們提供了一種記錄變換的有效方式（後續）。

新的程式碼如下：

type Person struct {
  name      string
  favoriteColors []string
}

func (p Person) WithName(name string) Person {
  p.name = name
  return p
}

func (p Person) Name() string {
  return p.name
}

func (p Person) WithFavoriteColors(favoriteColors []string) Person {
  p.favoriteColors = favoriteColors
  return p
}

func (p Person) FavoriteColors() []string {
  return p.favoriteColors
}

需要注意的關鍵點如下：

Person 的屬性都是私有的，因此外部包無法繞過 Person 提供的方法來訪問其屬性
Person 的方法接收的不是 *Person。這就保證了結構通過值傳遞，返回的也是值
注意一下：我用了“With”而不是“Set”來表明重要的是返回值且原始物件並沒有像呼叫 setter 那樣被更改
對同一個包下的程式碼來說，所有屬性依然是可訪問（也就可更改）的。我們絕不應該直接和屬性互動，而是在同一個包下也應一直堅持使用方法
每個 wither 返回的都是 Person，所以他們是可串聯的

 me := Person{}.
   WithName("Elliot").
   WithFavoriteColors([]string{"black","blue"})

 fmt.Printf("%+#v\n",me)
 // main.Person{name:"Elliot",favoriteColors:[]string{"black","blue"}}

處理切片

目前為止仍然不是完美的，因為對於最愛顏色我們返回的是切片。由於切片通過引用傳遞，我們來看看這麼一個稍不留神就會忽略的 bug：

func updateFavoriteColors(p Person) Person {
  colors := p.FavoriteColors()
  colors[0] = "red"

  return p
}

func main() {
  me := Person{}.
    WithName("Elliot").
    WithFavoriteColors([]string{"black","blue"})

  me2 := updateFavoriteColors(me)

  fmt.Printf("%+#v\n",me)
  fmt.Printf("%+#v\n",me2)
}

// main.Person{name:"Elliot",favoriteColors:[]string{"red","blue"}}
// main.Person{name:"Elliot","blue"}}

我們想要改變第一種顏色，但是連帶地改變了 me 變數。因為在複雜應用程式中這不會導致程式碼無法執行，試圖搜尋出這麼個變化是相當煩人和耗時的。

解決方法之一是確保我們絕不通過索引賦值，而是永遠都是分配一個新的切片：

func updateFavoriteColors(p Person) Person {
  return p.WithFavoriteColors(append([]string{"red"},p.FavoriteColors()[1:]...))
}

// main.Person{name:"Elliot","blue"}}

在我看來，這有點拙而且容易出錯。更好的方式是一開始就不返回切片。拓展我們的 getter 和 wither 來僅對元素操作（而不是整個切片）：

func (p Person) NumFavoriteColors() int {
  return len(p.favoriteColors)
}

func (p Person) FavoriteColorAt(i int) string {
  return p.favoriteColors[i]
}

func (p Person) WithFavoriteColorAt(i int,favoriteColor string) Person {
  p.favoriteColors = append(p.favoriteColors[:i],append([]string{favoriteColor},p.favoriteColors[i+1:]...)...)


  return p
}

譯者注：上述程式碼是錯誤的，如果p.favoriteColors的容量大於i則會就地改變副本的favoriteColors，參見反例，稍作調整即可得到正確實現

現在我們就可以放心使用：

func updateFavoriteColors(p Person) Person {
  return p.WithFavoriteColorAt(0,"red")
}

想要了解更多切片的妙用參見這篇牛逼的wiki：https://github.com/golang/go/wiki/SliceTricks

建構函式

某些情況下，我們會假設結構體的預設值是合理的。但是，強烈建議總是建立建構函式，一旦將來需要改變預設值時，我們只需要改動一個地方：

func NewPerson() Person {
  return Person{}
}

你可以隨心所欲地例項化 Person，但個人偏愛總是通過 setter 來執行狀態變換從而保持程式碼一致性：

func NewPerson() Person {
  return Person{}.
    WithName("No Name")
}

介面 (Interface)

到現在為止，我們使用的還是公有的結構體。任由這些結構體方法擺佈之下，加上建立 mock 可能會引發非預期的副作用，測試起來會很痛苦。

我們可以建立一個同名的介面，並把相應的結構體重新命名為 person 使之私有化：

type Person interface {
  WithName(name string) Person
  Name() string
  WithFavoriteColors(favoriteColors []string) Person
  NumFavoriteColors() int
  FavoriteColorAt(i int) string
  WithFavoriteColorAt(i int,favoriteColor string) Person
}

type person struct {
  name      string
  favoriteColors []string
}

我們現在就可以只重寫想要替換的邏輯來建立測試 mock：

type personMock struct {
  Person
  receivedNewColor string
}

func (m personMock) WithFavoriteColorAt(i int,favoriteColor string) Person {
  m.receivedNewColor = favoriteColor
  return m
}

測試程式碼樣例如下：

mock := personMock{}
result := updateFavoriteColors(mock)

result.(personMock).receivedNewColor // "red"

記錄變化

如我早前所言，完整的狀態轉換非常有益於除錯，而且我們可以 wither 來掛入鉤子的方式捕捉到所有或部分變換過程：

func (p person) nextState() Person {
  fmt.Printf("nextState: %#+v\n",p)
  return p
}

func (p person) WithName(name string) Person {
  p.name = name
  return p.nextState() // <- Use "nextState" whenever you return.
}

對於更加複雜的邏輯或個人偏好，你也可以採用 defer 的方式：

func (p person) WithFavoriteColors(favoriteColors []string) Person {
  defer func() {
    p.nextState()
  }()

  p.favoriteColors = favoriteColors
  return p
}

這樣變換就可看到了：

nextState: main.person{name:"No Name",favoriteColors:[]string(nil)}
nextState: main.person{name:"Elliot","blue"}}

你可以新增更多諸如此類的資訊。例如，時間戳、棧追蹤記錄和其他自定義的上下文資訊來使得除錯更加容易。

歷史及回滾

除了列印變化之外，我們還可以收集這些狀態作為歷史：

type Person interface {
  // ...
  AtVersion(version int) Person
}

type person struct {
  // ...
  history    []person
}

func (p *person) nextState() Person {
  p.history = append(p.history,*p)
  return *p
}

func (p person) AtVersion(version int) Person {
  return p.history[version]
}

func main() {
  me := NewPerson().
    WithName("Elliot").
    WithFavoriteColors([]string{"black","blue"})

  // We discard the result,but it will be put into the history.
  updateFavoriteColors(me)

  fmt.Printf("%s\n",me.AtVersion(0).Name())
  fmt.Printf("%s\n",me.AtVersion(1).Name())
}

// No Name
// Elliot

這非常利於最後進行審查。記錄所有日誌列印的歷史對處理後續異常的場景也是很有用的，如果不需要的話，讓歷史隨例項消亡即可。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。