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

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

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

引言

面向對象編程語言最基礎的概念就是類(class)，不過Go語言并沒有類的概念，所以使用Go語言開發(fā)時，我們一般會用struct(結構體)來模擬面向對象中的類。

類一般是通過構造方法(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: "高中二年級",
	}
}

使用內置new函數

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

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

構造函數

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

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

一般我們自定義的構造函數都以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()函數，之后可以在其他包復用該函數來初始化struct，將Student改為student，這樣其他包無法直接訪問student結構體，達到了封裝的效果，而在NewStudent()函數中，我們也可以驗證參數是否合理。

當然自定義構造函數也是必須以New為前綴的，比如標準庫os包中，初始化文件句柄時，可以使用Open()，Create()和OpenFile()等函數來初始化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
}

支持可變參數的構造函數

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

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

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
}

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

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

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),
	)	
}

折中方案

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

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