Go語言的結構體如何使用

這篇文章主要介紹“Go語言的結構體如何使用”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Go語言的結構體如何使用”文章能幫助大家解決問題。

定義

結構體，是一種自定義的數據類型，由多個數據類型組合而成。用于描述一類事物相關屬性。

定義方式：

type 類型名 struct {
    字段名 字段類型
    …
}

//示例：
type Animal struct {
  Name string
  Age  int
}

實例化

結構體和結構體指針，兩者的實例化有所區別

提供多種寫法，靈活使用：

//結構體實例化
//寫法1
//var a Animal 
//a.Name = "aaa"
//a.Age = 18
//寫法2
a := Animal{ 
  Name: "dog",
  Age:  18,
}
fmt.Println(fmt.Sprintf("%T - %v", a, a)) //main.Animal - {dog 18}

//結構體指針實例化
//寫法1
var b *Animal 
b = new(Animal)
//寫法2
//b := new(Animal)  
//寫法3
//b := &Animal{}    
b.Name = "cat"                            //在底層是(*b).Name = "cat"，這是Go語言幫我們實現的語法糖
fmt.Println(fmt.Sprintf("%T - %v", b, b)) //*main.Animal - &{cat 0}

注意：結構體指針必須手動初始化，分配內存地址

匿名結構體

適用于臨時數據存儲的場景

var v struct {
  Name string
  Age  int
}
fmt.Println(v)

空結構體

不占用內存空間

var v struct{}
fmt.Println(unsafe.Sizeof(v)) //0

v1 := struct{}{}
fmt.Println(unsafe.Sizeof(v1)) //0

構造函數

Go沒有自帶的構造函數，采用自實現

方式1

結構體不復雜，可以返回結構體類型，值拷貝性能開銷小

func NewPerson(name string, age int8) Person {
  return Person{
    name: name,
    age:  age,
  }
}

定義方式2

結構體復雜，得返回結構體指針類型，避免值拷貝產生的性能開銷

func NewPerson(name string, age int8) *Person {
  return &Person{
    name: name,
    age:  age,
    sex:  sex,
    country:country,
    province:province,
    city:city,
    town:town,
    address:address,
  }
}

方法與接收者

方法（Method）是一種作用于特定類型變量的函數。這種特定類型變量叫做接收者（Receiver）。接收者的概念就類似于PHP中的this或者 self。

方法與函數區別：函數不屬于任何類型，方法屬于特定類型。函數沒有接收者，方法有接收者。

標準格式：

func (接收者變量 接收者類型) 方法名(參數列表) (返回參數) {
    函數體
}

接收者類型（兩種）：

• 非指針類型：發生值拷貝產生副本，方法內修改字段，只在方法內生效；

• 指針類型：不產生副本，方法內修改字段，同步生效；

func NewPerson(name string, age int8) *Person {
  return &Person{
    name: name,
    age:  age,
  }
}

func (p *Person) Dream() {
  p.name = "aaa"
  fmt.Printf("%s的夢想是學好Go語言\n", p.name)  //aaa的夢想是學好Go語言
}

func main() {
  p1 := NewPerson("小王子", 25)
  p1.Dream()
  fmt.Println(p1) //&{aaa 25}
}

什么時候使用指針類型的接收者：

• 需要修改接收者中的值

• 接收者是拷貝代價比較大的大對象

• 保證一致性，在同一個文件中，如果有某個方法使用了指針接收者，那么其他的方法也建議使用指針接收者

注意點：

1.接收者類型，可以是任何類型，不僅僅只針對結構體類型。但要注意下，類型和方法定義需要在同一個包下面

type MyInt int

func (i MyInt) SayInt() {
  fmt.Println("my type is MyInt")
}

func main() {
  var i1 MyInt
  i2 := MyInt(10)
  i1.SayInt()
  i2.SayInt()
}

輸出結果：
my type is MyInt
my type is MyInt

匿名字段

結構體允許其成員字段在聲明時沒有字段名而只有類型，這種沒有名字的字段就稱為匿名字段

type User struct {
  Name    string
  Gender  string
  Address //匿名字段
}

type Address struct {
  Province   string
  City       string
  CreateTime string
}

func main() {
  var u1 User
  u1.Name = "張三"
  u1.Gender = "男"
  u1.Address.City = "北京" //匿名字段默認使用類型名作為字段名
  u1.CreateTime = "2019" //匿名字段可以省略，但注意多個匿名字段下有相同字段名，會編譯失敗，所以建議不采用省略寫法
  fmt.Println(u1)
}

但需要注意字段名沖突問題，所以不建議使用省略寫法操作匿名字段

實現面向對象的“繼承”特性

Go不是面向對象編程的語言，但可以通過嵌套結構體的方式，來實現面向對象的“繼承”特性

type Animal struct {
  Name string
  Age  int
}

func (a Animal) Say() {
  fmt.Println(fmt.Sprintf("1-my name is %s and age is %d", a.Name, a.Age))
}

type Cat struct {
  Animal //嵌套結構體實現繼承
}

func main() {
  c1 := Cat{}
  c1.Name = "加菲貓"
  c1.Age = 5
  c1.Say()

  //輸出結果：
  //1-my name is 加菲貓 and age is 5
}

子類還可以重寫父類的Say方法，并且還能擁有自己的Run方法：

func (c Cat) Say() {
  fmt.Println(fmt.Sprintf("2-my name is %s and age is %d", c.Name, c.Age))
}

func (c Cat) Run() {
  fmt.Println(fmt.Sprintf("my name is %s，還是跑步高手", c.Name))
}

func main() {
  c1 := Cat{}
  c1.Name = "加菲貓"
  c1.Age = 5
  c1.Say()
  c1.Run()

  //輸出結果：
  //2-my name is 加菲貓 and age is 5
  //my name is 加菲貓，還是跑步高手
}

標簽tag

通過反射機制，識別結構體的標簽，容錯能力較差，需要注意使用

標準格式：

`key1:"value1" key2:"value2"`

使用注意事項：

• 外層使用 反引號 包起來，里邊value需要使用 雙引號 包起來；

• KV之間使用冒號，多個KV之間使用空格； （注意：冒號前后不要加其他符號）

結構體與JSON系列化

給結構體添加json標簽，然后做json序列化操作：

• 首字母大寫字段（公開） ：會轉換成json標簽指定的字段名，若未指定，則使用自身字段名；

• 首字小寫字段（私有） ：不會輸出，因為這類字段僅在定義當前結構體的包中可訪問；

簡單示例：

type CardInfo struct {
  Title  string `json:"title"`
  Desc   string
  height int `json:"height"`
}

func main() {
  c1 := CardInfo{
    Title:  "成長之星",
    Desc:   "balabala",
    height: 100,
  }
  data, _ := json.Marshal(c1)
  fmt.Println(string(data)) //{"title":"成長之星","Desc":"balabala"}

  str := "{"title":"title111", "desc":"desc222", "height":20}"
  c2 := CardInfo{}
  _ = json.Unmarshal([]byte(str), &c2)
  fmt.Println(c2) //{title111 desc222 0}
}

空結構體

上文為大家簡單介紹了空結構體，使用unsafe.SizeOf()方法，明確知道了空結構體，它不占用存儲空間。

（即“寬度”為0，寬度描述了一個類型的實例所占用的存儲空間的字節數）

s := struct{}{}
fmt.Println(unsafe.Sizeof(s)) //0

在項目代碼中，我們經常都會看到空結構體struct{}{}的使用，它有什么作用，適合什么場景使用呢？

空結構體作用

請大家注意：結構體包含一個指針和指針指向的數據，下文所說的不占用內存其實指的是指針指向的數據為null，但是空結構體最為一個變量它的指針肯定是占用內存空間的，只是單用很小。

因為空結構體的值不占據內存空間的特性，因此被廣泛作為各種場景下的占位符使用。

• 一是節省資源

• 二是空結構體本身就具備很強的語義：即這里不需要任何值，僅作為占位符。

空結構體使用場景

主要使用場景有3個：

• 實現集合類型

• 實現空通道

• 實現方法接收者

下面逐個為大家詳解

1.實現集合類型

Go語言本身是沒有集合類型（Set），通常是使用map來替代。

但有個問題：就是集合類型，只需要用到key（鍵），不需要用到value（值）

如果value使用bool來表示，實際會占用1個字節的空間，為了節省空間，這時空結構體就可以大顯身手了

type Set map[int]struct{}

func main() {
  s := make(Set)
  s.add(1)
  s.add(2)
  s.add(3)
  s.remove(2)
  fmt.Println(s.exist(1))
  fmt.Println(s)

  //輸出：
  //true
  //map[1:{} 3:{}]
}
func (s Set) add(num int) {
  s[num] = struct{}{}
}
func (s Set) remove(num int) {
  delete(s, num)
}
func (s Set) exist(num int) bool {
  _, ok := s[num]
  return ok
}

空結構體作為占位符，不會額外增加不必要的內存開銷，很方便的就把問題給解決了

2.實現空通道

在Go語言 channel的使用場景中，常常會遇到通知型 channel，其不需要發送任何數據，只是用于協調 Goroutine 的運行，用于流轉各類狀態或是控制并發情況。

這類情況就特別適合使用空結構體，只做個占位，不浪費內存空間

func main() {
  ch := make(chan struct{})
  go worker(ch)

  // Send a message to a worker.
  ch <- struct{}{}

  // Receive a message from the worker.
  <-ch
  println("AAA")

  //輸出：
  //BBB
  //AAA
}

func worker(ch chan struct{}) {
  // Receive a message from the main program.
  <-ch
  println("BBB")

  // Send a message to the main program.
  close(ch)
}

由于該 channel 使用的是空結構體，因此也不會帶來額外的內存開銷

3.實現方法接收者

使用結構體類型的變量作為方法接收者，有時結構體可以不包含任何字段屬性。這種情況，可以用int或者string來替代，但它們都會占用內存空間，所以使用空結構體是比較合適的。

并且也有利于未來針對該類型進行公共字段等的增加，容易擴展和維護

type T struct{}

func methodUse() {
  t := T{}
  t.Print()
  t.Print2()

  //輸出：
  //哈哈哈Print
  //哈哈哈Print2
}

func (t T) Print() {
  fmt.Println("哈哈哈Print")
}
func (t T) Print2() {
  fmt.Println("哈哈哈Print2")
}

關于“Go語言的結構體如何使用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。