使用Go初始化Struct的方法詳解

更新時間：2024年01月02日 11:00:06 作者：程序員讀書

面向?qū)ο缶幊陶Z言最基礎的概念就是類(class),不過Go語言并沒有類的概念,所以使用Go語言開發(fā)時,我們一般會用struct(結構體)來模擬面向?qū)ο笾械念?下面我們來介紹幾種創(chuàng)建struct類型變量的方法,需要的朋友可以參考下

引言

面向?qū)ο缶幊陶Z言最基礎的概念就是類(class)，不過Go語言并沒有類的概念，所以使用Go語言開發(fā)時，我們一般會用struct(結構體)來模擬面向?qū)ο笾械念悺?/p>

類一般是通過構造方法(constructors)來初始化類的實例(對象)中的屬性，不過Go的struct并沒有構造方法這種機制，那要怎么樣初始化struct類型的實例呢？

下面我們來介紹幾種創(chuàng)建struct類型變量的方法。

字面量

創(chuàng)建并初始化一個struct變量最簡單直接的方式就是使用struct字面量：

//app/school.go
package school

type Student struct {
	ID    int
	Name  string
	Score int
	Grade string
}

//main.go
package main
func main() {
	s := &Student{
		ID:    1,
		Name:  "小明",
		Score: 90,
		Grade: "高中二班",
	}
}

不過有時候我們只是需要一個臨時struct類型的話，可以使用匿名struct：

func main() {

	s := struct {
		ID    int
		Name  string
		Score int
		Grade string
	}{
		ID: 1, 
        Name: "小明",
        Score: 90,
        Grade: "高中二年級",
	}
}

使用內(nèi)置new函數(shù)

除了字面量外，使用Go內(nèi)置的new函數(shù)也可以創(chuàng)建一個struct變量，不過這種方式需要自己為struct的每個字段賦初始值：

func main(){
  s := new(Student)
  s.ID = 1
  s.Name = "小明"
  s.Score = 90
  s.Grade = "高中二班"
}

構造函數(shù)

前面我們說過Go語言的struct沒有構造函數(shù)，但是我們可以自定義函數(shù)來初始化struct，自定義函數(shù)的好處在于：

可以達到復用的目的。
可以起到封裝的效果。
可以校驗初始化值是否在允許的范圍內(nèi)。

一般我們自定義的構造函數(shù)都以New為前綴，比如：

package school

type student struct {
	ID    int
	Name  string
	Score int
	Grade string
}

func NewStudent(ID int, Name string,Score int Grade string) *Student {
    if ID < 0{
        panic("ID不能小于0")
    }
    
    if Score < 0 || Score > 100{
        panic("Score必須在0~100之間")
    }
    
    s := new(Student)
    s.ID = 1
    s.Name = "小明"
    s.Score = 90
    s.Grade = "高中二班"
    return s
}

package main 

import "app/school"

func main(){
    s := school.NewStudent(1,"小明",90,"高中二班")
}

上面的例子中，我們自定義了NewStudent()函數(shù)，之后可以在其他包復用該函數(shù)來初始化struct，將Student改為student，這樣其他包無法直接訪問student結構體，達到了封裝的效果，而在NewStudent()函數(shù)中，我們也可以驗證參數(shù)是否合理。

當然自定義構造函數(shù)也是必須以New為前綴的，比如標準庫os包中，初始化文件句柄時，可以使用Open()，Create()和OpenFile()等函數(shù)來初始化os.File：

//os包的file.go文件的代碼
func Open(name string) (*File, error) {
	return OpenFile(name, O_RDONLY, 0)
}

func Create(name string) (*File, error) {
	return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}

func OpenFile(name string, flag int, perm FileMode) (*File, error) {
	testlog.Open(name)
	f, err := openFileNolog(name, flag, perm)
	if err != nil {
		return nil, err
	}
	f.appendMode = flag&O_APPEND != 0

	return f, nil
}

支持可變參數(shù)的構造函數(shù)

在上面的例子中，我們可以通過NewStudent()函數(shù)創(chuàng)建一個student類型的變量，但是這個構造函數(shù)的參數(shù)的順序與個數(shù)是固定的，如果有多個地方調(diào)用NewStudent()函數(shù)，此時在該函數(shù)新增一個參數(shù)時，那么所有調(diào)用到該函數(shù)的代碼都必須調(diào)整。

我們可以再優(yōu)化一下我們的構造函數(shù)，使用其參數(shù)的個數(shù)與順序是可變的：

package school

type student struct {
	ID    int
	Name  string
	Score int
	Grade string
}

type StudentOptionFunc func(*student)

func WithID(id int) StudentOptionFunc {
	return func(s *student) {
		s.ID = id
	}
}

func WithName(name string) StudentOptionFunc {
	return func(s *student) {
		s.Name = name
	}
}

func WithScore(score int) StudentOptionFunc {
	return func(s *student) {
		s.Score = score
	}
}

func WithGrade(grade string) StudentOptionFunc {
	return func(s *student) {
		s.Grade = grade
	}
}

func NewStudent(opts ...StudentOptionFunc) *student {
	s := &student{}
	for _, opt := range opts {
		opt(s)
	}
	return s
}

上面的例子中，構造函數(shù)NewStudent()的參數(shù)是不定長StudentOptionFunc類型的函數(shù)，可以看作是一個裝了多個函數(shù)的切片，在NewStudent()函數(shù)內(nèi)部遍歷這個切片，通過切片中的每個函數(shù)來初始化自己的字段。

接下來在調(diào)用中，我們就可以不受參數(shù)個數(shù)與順序的影響來調(diào)用NewStudent()函數(shù)了：

package main

import (
	"app/school"
	"fmt"
)

func main() {
	s1 := school.NewStudent(
		school.WithName("小明"), 
        school.WithScore(90),
        school.WithID(1),
        school.WithGrade(""),
	)	
    
    s2 := school.NewStudent(
		school.WithName("小花"), 
        school.WithScore(90),
	)	
}

折中方案

上面演示了兩種自定義構造函數(shù)，一種初始化參數(shù)個數(shù)與順序完全固定，這種方式太死板了，而一種則是可以自由傳入?yún)?shù)的順序與個數(shù)，這種方式又太自由了，因為我們可以想一個折中的方案，即把兩種方式結合起來：

func NewStudent(id int, Name string, opts ...StudentOptionFunc) *student {
	s := &student{ID: id, Name: Name}
	for _, opt := range opts {
		opt(s)
	}
	return s
}