浅谈用Go构建不可变的数据结构的方法
共享状态是比较容易理解和使用的，但是可能产生隐晦以至于很难追踪的 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", favoritecolors:[]string{"red", "blue"}}
我们想要改变第一种颜色，但是连带地改变了 me 变量。因为在复杂应用程序中这不会导致代码无法运行，试图搜寻出这么个变化是相当烦人和耗时的。
解决方法之一是确保我们绝不通过索引赋值，而是永远都是分配一个新的切片：
func updatefavoritecolors(p person) person {
return p.withfavoritecolors(append([]string{"red"}, p.favoritecolors()[1:]...))
}
// main.person{name:"elliot", favoritecolors:[]string{"black", "blue"}}
// main.person{name:"elliot", favoritecolors:[]string{"red", "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", favoritecolors:[]string(nil)}
nextstate: main.person{name:"elliot", favoritecolors:[]string{"black", "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
这非常利于最后进行审查。记录所有日志打印的历史对处理后续异常的场景也是很有用的，如果不需要的话，让历史随实例消亡即可。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。