Go语言结构体struct详解，Go空结构体的这些妙用你知道吗？

Posted 2023-03-30 王中阳Go

本文详解了Go语言结构体的各个知识点，最后介绍了空结构体的3种妙用。希望对你有帮助。

定义

结构体，是一种自定义的数据类型，由多个数据类型组合而成。用于描述一类事物相关属性。

定义方式：

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. 需要修改接收者中的值
2. 接收者是拷贝代价比较大的大对象
3. 保证一致性，在同一个文件中，如果有某个方法使用了指针接收者，那么其他的方法也建议使用指针接收者

注意点：

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之间使用空格； （注意：冒号前后不要加其他符号）

使用示例：

goframe v2的标准路由注册就是使用标签tag的方式定义的，大家感兴趣可以看下我们开源项目的代码：

https://github.com/wangzhongyang007/goframe-shop-v2

结构体与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，但是空结构体最为一个变量它的指针肯定是占用内存空间的，只是单用很小。

因为空结构体的值不占据内存空间的特性，因此被广泛作为各种场景下的占位符使用。

1. 一是节省资源
2. 二是空结构体本身就具备很强的语义：即这里不需要任何值，仅作为占位符。

空结构体使用场景

主要使用场景有3个：

1. 实现集合类型
2. 实现空通道
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语言结构体的各种知识点，最后针对空结构体的作用和使用场景，进行了详细的讲解。在之后的实际项目开发过程中，只用占位不用实际含义，那么我们就都可以使用空结构体，可以极大的节省不必要的内存开销。

希望对大家有帮助，兄弟们觉好留言哦。

坚持写作

这篇文章来自知识星球中劲仔的投稿，欢迎加入我们，坚持写作输出，一起成长进步。

Golang 入门 : 结构体(struct)

Go 通过类型别名(alias types)和结构体的形式支持用户自定义类型，或者叫定制类型。试图表示一个现实世界中的实体。

结构体由一系列命名的元素组成，这些元素又被称为字段，每个字段都有一个名称和一个类型。
结构体的目的就是把数据聚集在一起，以便能够更加便捷地操作这些数据。结构体的概念在 C 语言里很常见，被称为 struct。Golang 中的结构体也是 struct。Go 语言中没有类的概念，因此在 Go 中结构体有着更为重要的地位。结构体是复合类型(composite types)，当需要定义一个类型，它由一系列属性组成，每个属性都有自己的类型和值的时候，就应该使用结构体，它把数据聚集在一起。然后可以访问这些数据，就好像它是一个独立实体的一部分。结构体也是值类型，因此可以通过 new 函数来创建。

定义结构体
在 Golang 中最常用的方法是使用关键字 type 和 struct 来定义一个结构体，以关键字 type 开始，之后是新类型的名字，最后是关键字 struct：

// Person 为用户定义的一个类型
type Person struct {
Name string
Age int
Email string
}
还有一些简单的写法，比如：

type T struct { a, b int }
也是合法的，它更适用于简单的结构体。

结构体里的字段都有名字，比如上面例子中的 Name、Age 和 Email 等等。如果一个字段在代码中从来不会被用到，那可以把它命名为 _，即空标识符。

结构体中的字段可以是任何类型，甚至是结构体本身，也可以是函数或者接口。可以声明结构体类型的一个变量，然后像下面这样给它的字段赋值：

var p Person
p.Name = "nick"
p.Age = 28
另外，数组可以看作是一种结构体类型，不过它使用下标而不是具名的字段。

字段标记
在定义结构体时还可以为字段指定一个标记信息：

type Person struct {
Name string json:"name"
Age int json:"age"
Email string json:"email"
}
这些标记信息通过反射接口可见，并参与结构体的类型标识，但在其他情况下被忽略。

声明结构体类型的变量
一旦定义了结构体类型就可以使用这个类型创建值。

使用结构类型声明变量，并初始化为零值

var nick Person
关键字 var 创建了类型为 Person 且名为 nick 的变量。nick 被称作类型 Person 的一个实例(instance)或对象(object)。注意：当声明变量时，这个变量对应的值总是会被初始化。这个值要么用指定的值初始化，要么用零值(即变量类型的默认值)做初始化。对数值类型来说，零值是 0；对字符串来说，零值是空字符串；对布尔类型，零值是 false。

通过上面的方式声明结构体类型的变量，结构体里的每个字段都会用零值初始化。任何时候，创建一个变量并初始化为零值，习惯上会使用关键字 var。这种用法是为了更明确地表示一个变量被设置为零值。

使用结构体字面量声明变量，并初始化为非零值
如果希望变量被初始化为某个非零值，可以通过结构体字面量和短变量声明操作符(:=)来创建变量。下面的代码展示了如何声明一个 Persion 类型的变量，并使用某个非零值作为初始值。

// 声明 Person 类型的变量，并初始化所有字段
nick := Person{
Name: "nick",
Age: 28,
Email: "[e-mail]",
}
在第一行中我们给出了一个变量名 nick，之后是短变量声明操作符。这个操作符是冒号加一个等号 (:=)。一个短变量声明操作符在一次操作中完成两件事情：声明一个变量，并初始化。短变量声明操作符会使用右侧给出的类型信息作为声明变量的类型。

短变量声明操作符(:=)
它的作用是声明并且赋值一个变量，其好处是不需要写 var 三个字母，另外不需要写类型，Golang 语言会自动根据赋值的内容确定类型。

使用短变量声明操作符也有一些限制，比如不能在函数外面使用，即不能用来声明全局变量。另外短变量声明操作符左边至少得有一个变量是没有定义过的。

字面量的两种写法
结构体字面量可以对结构体类型进行初始化，比如前面介绍过的示例：

nick := Person{
Name: "nick",
Age: 28,
Email: "[e-mail]",
}
这种形式在不同行声明每个字段的名字以及对应的值。字段名与值用冒号分隔，每一行以逗号结尾。这种形式对字段的声明顺序没有要求。
第二种形式没有字段名，只声明对应的值，如下面的代码：

nick := Person{"nick", 28, "[e-mail]"}
每个值也可以分别占一行，不过习惯上这种形式会写在一行里，结尾不需要逗号。这种形式下，值的顺序很重要，必须要和结构声明中字段的顺序一致。

new 函数
new 是一个用来分配内存的内置函数，但是与 C++ 不一样的是，它并不初始化内存，只是将其置零。也就是说，new(T) 会为类型 T 分配被置零的内存，并且返回它的地址，一个类型为 *T 的值。在 Golang 的术语中，其返回一个指向新分配的类型为 T 的指针，这个指针指向的内容的值为零(zero value)。比如下面的代码：

nick := new(Person)
这里的变量 nick 是一个指针：

fmt.Printf("%T", nick)
输出的结果为：*main.Student
而通过下面方式声明的变量：

var nick Person
类型则是：main.Student

使用 new 函数时，声明变量和分配内存并不需要放在一起，可以先声明一个变量，然后再通过 new 函数为之分配内存，比如下面的写法：
var nick *Person
nick = new (Person)

new 函数的特点是只能把内存初始化为零值并返回其指针，如果要通过字面量初始化该内存就需要使用混合字面量语法(composite literal syntax)：
&T{...}
比如下面的写法：

nick := &Person{
Name: "nick",
Age: 28,
Email: "[e-mail]",
}
此时 nick 的类型也是 *Person。因此我们可以得出下面的结论：
表达式 new(Type) 和 &Type{} 是等价的。

选择器(selector)
在 Golang 中，访问结构体成员需要使用点号操作符，点号操作符也被称为选择器(selector)，使用时的格式为：

结构体.成员名
注意：这里的 "结构体" 是指结构体类型的变量或结构体指针类型的变量。无论变量是一个结构体类型还是一个结构体类型指针，都可以使用相同的选择器服务来引用结构体的字段。

匿名字段和内嵌结构体
结构体可以包含一个或多个匿名(或者称为内嵌)字段，即这些字段没有显式的名字。仅指明字段的类型，此时该类型就是字段的名字。匿名字段本身可以是一个结构体类型，即结构体可以包含内嵌的结构体。

匿名字段
匿名字段和面向对象编程中的继承概念相似，可以被用来模拟类似继承的行为。Golang 中的基础就是通过内嵌或组合来实现的，所以说在 Golang 中组合比继承更受欢迎。比如下面的例子：

type test struct {
name string
age int
int // 匿名字段
}
内嵌结构体
结构体也是一种数据类型，所以它同样可以作为匿名字段使用：

复制代码
type Person struct {
Name string
Age int
Email string
}
type Student struct {
Person
StudentID int
}
复制代码
下面的代码可以声明并初始化 Student 类型的变量：

st := Student {
Person: Person{"jack", 22, "[e-mail]"},
StudentID: 1000,
}
从这个示例可以看出，内层结构体被简单地插入或者内嵌进外层结构体。这种简单的 "继承" 机制使得 Golang 很轻松就能实现从一个或一些类型中继承部分或全部的实现。

总结
Golang 中没有类的概念，因此在 Golang 中结构体有着更为重要的地位。所以学习并掌握结构体是入门 Golang 的关键步骤。希望本文能够帮助大家理解 Golang 结构体的基本概念和用法。

参考：
Golang Struct types
《Go语言编程入门与实战技巧》
结构体定义
go 语言的变量声明并赋值运算符(:=)