Go创建对象时，如何优雅的传递初始化参数

Go创建对象时，如何优雅的传递初始化参数？这里所说的优雅，指的是：

支持传递多个参数
参数个数、类型发生变化时，尽量保持接口的兼容性
参数支持默认值
具体的参数可根据调用方需关心的程度，决定是否提供默认值

Go并不像c++和python那样，支持函数默认参数。所以使用Go时，我们需要一种方便、通用的手法来完成这件事。

Go的很多开源项目都使用Option模式，但各自的实现可能有些许细微差别。

本文将通过一个渐进式的demo示例来介绍Option模式，以及相关的一些思考。本文将内容切分为10个小模块，如果觉得前面的铺垫冗余，想直接看Option模式的介绍，可以从小标题七开始阅读。

零

先看demo，一开始我们的代码是这样的：

type Foo struct {
  num int
  str string

  // ...
}

func New(num int, str string) *Foo {
  // ...

  return &Foo{
    num: num,
    str: str,
  }
}

// ...

我们有一个Foo结构体，内部有num和str两个属性，New函数传入两个初始化参数，构造一个Foo对象。

ok，一切都足够简单。

假设我们需要对Foo内部增加两个属性，同时构造函数也需要支持传入这两个新增属性的初始值。有一种修改方法是这样的：

1	func New(num int, str string, num2 int, str2 string)

可以看到，这种方式，随着初始化参数个数、类型的变化，我们New函数的函数签名也需随之改变。这带来两个坏处：

对调用方来说，函数不兼容
参数数量太多，可读性可能变差

一

有一种保持兼容性的解决方案，是保留之前的New函数，再创建一个新的构造函数，比如New2，用于实现4个参数的构造方法。

这种解决方案在大部分时候会导致代码可维护性下降。

二

另一种解决方案，是把所有的参数都放入一个结构体中。就像这样：

type Foo struct {
  option Option

  // ...
}

type Option struct {
  num int
  str string
}

func New(option Option) *Foo {
  // ...

  return &Foo{
    option: option,
  }
}

这种方式，解决了上面提出的两个问题。但是，假设我们想为参数提供默认参数呢？

比如说当调用方不设置num时，我们希望它的默认值是100；不设置str时，默认值为hello。

三

// 构造对象时只设置 str，不设置 num
foo := New(Option{
  str: "world",
})

这种做法可行的前提是，属性的默认值也为0值。

假设我们希望option.num属性默认值是100，那么当内部接收到的option.num为0时，我们没法区分是调用方希望将option.num设置为0，还是调用方压根就没设置option.num。从而导致我们不知道将内部的option.num设置为0好，还是保持默认值100好。

事实上，这个问题不仅仅是传递Option时才会出现，即使所有参数都使用最上面那种直接传递的方式，也会存在这个问题，即0值无法作为外部是否设置的判断条件。

四

有一种解决方案，是使用*Option即指针类型作为初始化参数，如果外部传入为nil，则使用默认参数。代码如下：

func New(option *Option) *Foo {
  if option == nil {
    // 外部没有设置参数
  }
}

该方案存在的问题是，所有的参数要么全部由外部传入，要么全部使用默认值。

如何才能细化到每一个具体的参数，外部设置了使用外部设置的值，外部没有设置则使用默认值呢？

五

一种解决方案，是Option中的所有属性，都使用指针类型，如果特定参数为nil，则该参数使用默认参数。代码如下：

type Option struct {
  num *int
  str *string
}

func New(option Option) *Foo {
  if option.num == nil {
    // num 使用默认值
  } else {
    // option.num 即为调用方设置的初始值
  }
  // ...
}

该方案存在的问题是，对于调用方来说，使用起来有些反人类，因为你无法使用类似&1的写法对一个整型字面常量取地址，这意味着调用方必须格外定义一个变量保存他需要设置的参数的值，然后再对这个变量取地址赋值给Option的属性。代码如下：

// // 下面这种写法会造成编译错误
// option := {
//     num: &200,
//     str: &"world",
// }
//
// // 只能这样写
// num := 200
// str := "world"
// option := {
//     num: &num,
//     str: &str,
// }
// foo := New(option)

看起来有点，额，不太优雅。

六

另一种值得一提的解决方案，是使用Go可变参数的特性。代码如下：

func New(num int, str string, num2 ...int) {
  if len(num2) == 0 {
    // 调用方没有设置 num2，内部的 num2 应使用默认值
  } else {
    // num2[0] 即为调用方设置的初始值
  }
}

该方案存在的问题是，只能有一个参数有默认值。

七

ok，说了这么多，是时候开始上主菜了。Go是支持头等函数的语言，即可以将函数作为变量传递。所以我们可以像下面这样写：

type Option struct {
  num int
  str string
}

type ModOption func(option *Option)

func New(modOption ModOption) *Foo {
  // 默认值
  option := Option{
    num: 100,
    str: "hello",
  }

  modOption(&option)

  return &Foo{
    option: option,
  }
}

我们的New函数不再直接接收Option的值，而是提供了一种类似于钩子函数的功能，使得在内部对option设置完默认值之后，调用方可以直接选择修改哪些属性。比如调用方只设置num，代码如下：

New(func(option *Option) {
  // 调用方只设置 num
  option.num = 200
})

八

那么假设有些时候，我们觉得某个参数是调用方必须关心的，不应该由内部设置默认值呢？我们可以这样写：

package main

type Foo struct {
  key string
  option Option

  // ...
}

type Option struct {
  num  int
  str  string
}

type ModOption func(option *Option)

func New(key string, modOption ModOption) *Foo {
  option := Option{
    num: 100,
    str: "hello",
  }

  modOption(&option)

  return &Foo{
    key: key,
    option: option,
  }
}

// ...

func main() {
  New("iamkey", func(option *Option) {
    // 调用方只设置 num
    option.num = 200
  })
}

九

最后再来一种常见的、高级点的写法。在上面代码的基础上，增加如下代码：

func WithNum(num int) ModOption {
  return func(option *Option) {
    option.num = num
  }
}

func WithStr(str string) ModOption {
  return func(option *Option) {
    option.str = str
  }
}

然后是调用方的代码：

// 可以这样写
foo := New("iamkey", WithNum(200))
// 还可以这样写
foo := New("iamkey", WithStr("world"))

能不能两个一起用呢？其实是可以的，结合我们上文讲到的可变参数，将New函数修改如下：

func New(key string, modOptions ...ModOption) *Foo {
  option := Option{
    num: 100,
    str: "hello",
  }

  for _, fn := range modOptions {
    fn(&option)
  }

  return &Foo{
    key: key,
    option: option,
  }
}

然后是使用方的代码：

1	New("iamkey", WithNum(200), WithStr("world"))

总结

至此，关于Option模式的介绍就结束啦。

事实上，Option模式除了在创建对象时可以使用，里面的一些API设计思想，Go的小技巧，在编写普通函数时也可以使用。

模式说白了就是一种套路。在实现功能的基础之上，大家都熟悉了某种固有套路的写法，都按着这个套路走，那么代码的可读性、可维护性就更高些。

对于一个特定场景，没有最好的模式，只有最适合的模式。不要过度设计，手里就一把锤子，瞅啥都是钉子。

举个例子，最后说的那种WithXXX写法，我个人认为在大部分时候都有点皮裤套棉裤，简单事情复杂化的感觉，不如只用一个ModOption直接修改option来得简单、直观，所以我几乎不用WithXXX的写法。但是在有些场景，你如果觉得提供WithXXX对调用方更友好，那么用用也挺好。

为了保持场景的纯粹性，上面的demo可能会有些抽象。如果你想进一步看看Option模式在实际项目中是如何使用的，可以看看我的这个开源项目：naza。该项目在构造对象时大量使用了Option模式。比如 consistenthash.go， bitrate.go 等等。并且做了一些私人化的风格规范。

最后，感谢阅读，如果觉得文章还不错，可以给我的github项目naza 来个star哈。该项目是我学习Go时写的一些轮子代码集合，后续我还会写一些文章逐个介绍里面的轮子以及一些写Go代码的技巧。

naza项目地址： https://github.com/q191201771/naza

naza的其他的文章：

给Go程序加入编译版本时间等信息

本文完，作者yoko，尊重劳动人民成果，转载请注明原文出处： https://pengrl.com/p/60015/