Go 程序不变性

正文

不变性的概念非常简单，在您创建结构体后，就永远无法修改它。这个概念听起来非常简单，但您的程序想利用它从中收益并不是那么容易。接下来我们在 Go 中，使用不变性概念，来让您的代码更具有可读性和稳定性。

减少对全局或外部状态的依赖

当我们使用相同的参数，执行相同的函数两次，我们的预期，应该得到相同的结果。但是当我们的函数中依赖外部状态或全局变量时，函数可能会输出不同的结果。我们最好避免这种情况。

函数的参数总是给定的，那我们调用，总是可以返回相同的函数。如果您有一个共享全局变量用于函数内部的某些内容，请考虑将该变量作为参数传递，而不是直接函数内部使用它。

这可以让您的函数返回值更加可预测，并且更加易于测试，整个代码的可读性也会得到提高，因为调用者会知道，哪些值会影响函数的行为，参数的作用不就是会影响返回值的吗？

让我们看一个例子。

package main
import (
   "fmt"
   "math/rand"
   "time"
)
var randNum int
func main() {
   s1 := rand.NewSource(time.Now().UnixNano())
   r1 := rand.New(s1)
   randNum = r1.Intn(100)
   fmt.Println(Add(1, 1))
}
func Add(a, b int) int {
   return a + b + randNum
}

Add 函数中使用了全局变量 randNum 作为计算的一部分，从函数签名中并没有体现这一点。更好的方法是，全局变量 randNum 应该作为参数传递，如下所示。

func Add(a, b, randNum int) int {
   return a + b + randNum
}

这样更具有可预测性，而且我们如果需要修改入参，影响的作用域也仅在 Add 函数中。

仅导出结构体的函数，而不是成员变量

我们知道，Go 结构体中的成员变量，如果首字母为大写，那么该成员变量对外可见（这是编译器决定的）。回到我们的博客，仅导出结构体函数，而不是成员变量，目的是希望成员变量的数据被保护，保证成员变量的有效的状态！因为这可以让您的代码更加可靠，您不必维护每个修改该成员变量的操作，因为这些操作都将无效。

举一个例子

ackage main
import (
	"fmt"
)
type AK47 struct {
	bullet int
}
func NewAK47(bullet int) AK47 {
	return AK47{bullet: bullet}
}
func (a AK47) GetBullet() int {
	return a.bullet
}
func (a AK47) SetBullet(bullet int) {
	a.bullet = bullet
}
func main() {
	ak47 := NewAK47(30)
	fmt.Println(ak47.GetBullet())
	ak47.SetBullet(20)
	fmt.Println(ak47.GetBullet())
}

我们定义了一个结构体 AK47，这把枪有一个成员变量 bullet 子弹数，它是非导出字段，我们还定义了一个构造函数 NewAK47 和一个 GetBullet 函数。

一旦创建了 AK47，就无法更改它的成员变量 bullet 了。此时您可能会有疑惑，如果我们需要修改成员变量呢？别急，您可以试试下面的方法。

在函数中使用复制值，而不是使用指针

在上一个副标题中，我们提到了一个概念，在创建结构体后永远不要更改它。然而在实际中，我们经常需要修改结构体中的成员变量。

我们在使用不变性的同时，仍然可以维护实例化结构体的多个状态，这并不意味着我们打破了结构体创建后不要更改它，我们更改的是它的副本，也就是复制后的结构体。复制后的结构体？难道我们需要去实现很多复制结构体每个字段的函数吗？

当然不，我们可以利用 Go 的特性，在调用函数时，入参是复制值的行为。对于需要修改结构体中成员变量的操作，我们可以创建一个函数，该函数接收结构体为参数，并且返回一个修改后的结构体副本。

我们可以在不改变调用方结构体的情况下，修改该副本的任何内容，这意味着对于原结构体没有任何副作用，并且该结构体的值仍然是可预测的。

不知道您有没有用过 Go 标准库的 Slice 切片，其中的 append 函数就使用了这个方法。让我们接着用 AK47 来实现这个方法

代码如下

package main
import (
	"fmt"
)
type AK47 struct {
	bullet int
}
func NewAK47(bullet int) AK47 {
	return AK47{bullet: bullet}
}
func (a AK47) GetBullet() int {
	return a.bullet
}
func (a AK47) AddBullet(ak47 AK47) AK47 {
	newAK47 := NewAK47(a.GetBullet() + ak47.GetBullet())
	return newAK47
}
func main() {
	ak47 := NewAK47(30)
	add := NewAK47(20)
	fmt.Println(ak47.GetBullet())
	ak47 = ak47.AddBullet(add)
	fmt.Println(ak47.GetBullet())
}

如您所见，我们通过 AddBullet 函数增加枪的子弹，但实际上并没有更改传入的结构体中的任何成员变量。最后，返回了一个带有更新字段的新 AK47 结构体。

与复制值相比，指针更有优势，尤其是当您的结构体成员变量、内容非常大时时，这种方法，通过复制的方式修改数据，可能会导致性能问题。您应该问自己，这么做是否值得，例如您正在编写并发代码？

总结

您在使用不变量时，请务必先权衡利弊。实现本篇博客中所描述的方法，需要大量的代码。但是，如果我们在编写并发代码时，不考虑共享变量的不可变性，往往会出现与预期不符的情况，例如内存竞态问题？其实我想说的就是线程安全问题 : - ）

实现不变性，也可能出现严重的性能问题！这是一把双刃剑。请不要过早的优化代码。