一种可能的想法是编写单独的构造函数

//Something is the structure we work with
type Something struct {
     Text string 
     DefaultText string 
} 
// NewSomething create new instance of Something
func NewSomething(text string) Something {
   something := Something{}
   something.Text = text
   something.DefaultText = "default text"
   return something
}

其中一种方法是:

// declare a type
type A struct {
    Filed1 string
    Field2 map[string]interface{}
}

因此，每当你需要一个自定义类型的新变量时，只需调用NewA函数，你也可以将函数参数化，可选地将值分配给struct字段

func NewA() *A {
    return &A{
        Filed1: "",
        Field2: make(map[string]interface{}),
    }
}

从https://golang.org/doc/effective_go.html # composite_literals:

有时0值还不够好，需要初始化构造函数，就像这个从包os派生的例子一样。

    func NewFile(fd int, name string) *File {
      if fd < 0 {
        return nil
      }
      f := new(File)
      f.fd = fd
      f.name = name
      f.dirinfo = nil
      f.nepipe = 0
      return f
}

对于Go结构体中的默认值，我们使用匿名结构:

Person := struct {
    name      string
    age       int
    city      string
}{
    name:      "Peter",
    age:        21,
    city:      "Noida",
}

fmt.Println(人)

选项1的一个问题是 Victor Zamanian认为，如果没有导出类型，那么包的用户就不能将其声明为函数参数的类型等。解决这个问题的一种方法是导出一个接口，而不是输出结构。

package candidate
// Exporting interface instead of struct
type Candidate interface {}
// Struct is not exported
type candidate struct {
    Name string
    Votes uint32 // Defaults to 0
}
// We are forced to call the constructor to get an instance of candidate
func New(name string) Candidate {
    return candidate{name, 0}  // enforce the default value here
}

这允许我们使用导出的Candidate接口声明函数参数类型。 我从这个解决方案中看到的唯一缺点是，我们所有的方法都需要在接口定义中声明，但你可能会说这是一种很好的实践。

type Config struct {
    AWSRegion                               string `default:"us-west-2"`
}