Go 语言结构体

1、Go 语言结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

1.1 定义结构体

结构体定义需要使用 type 和 struct 语句，struct 语句定义一个新的数据类型，结构体中有一个或多个成员。

type 语句设定了结构体的名称，结构体的格式如下：

type struct_variable_type struct {member definitionmember definition...member definition
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func main() {// 创建一个新的结构体// {Go语言 Tom Go语言教程 6495407}fmt.Println(Books{"Go语言", "Tom", "Go语言教程", 6495407})// 也可以使用 key => value 格式// {Go语言 Tom Go语言教程 6495407}fmt.Println(Books{title: "Go语言", author: "Tom", subject: "Go语言教程", book_id: 6495407})// 忽略的字段为0或空// {Go语言 Tom  0}fmt.Println(Books{title: "Go语言", author: "Tom"})
}

package mainimport "fmt"type Person struct {name stringage  int
}func main() {// 使用new创建内置函数,宇段默认初始化为其类型的零值,返回值是指向结构的指针p := new(Person)p.name = "tom"p.age = 27fmt.Println(p.name)fmt.Println(p.age)person := Person{"marry", 100}fmt.Println(person.name)fmt.Println(person.age)
}

# 程序输出
tom
27
marry
100

1.2 访问结构体成员

如果要访问结构体成员，需要使用点号.操作符，格式为：

结构体.成员名

结构体类型变量使用 struct 关键字定义。

// 实例如下
package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func main() {/* 声明 Book1 为 Books 类型 */var Book1 Books/* 声明 Book2 为 Books 类型 */var Book2 Books/* book 1 描述 */Book1.title = "Go语言"Book1.author = "Tom"Book1.subject = "Go语言教程"Book1.book_id = 6495407/* book 2 描述 */Book2.title = "Python教程"Book2.author = "Marry"Book2.subject = "Python语言教程"Book2.book_id = 6495700/* 打印 Book1 信息 */fmt.Printf("Book 1 title : %s\n", Book1.title)fmt.Printf("Book 1 author : %s\n", Book1.author)fmt.Printf("Book 1 subject : %s\n", Book1.subject)fmt.Printf("Book 1 book_id : %d\n", Book1.book_id)/* 打印 Book2 信息 */fmt.Printf("Book 2 title : %s\n", Book2.title)fmt.Printf("Book 2 author : %s\n", Book2.author)fmt.Printf("Book 2 subject : %s\n", Book2.subject)fmt.Printf("Book 2 book_id : %d\n", Book2.book_id)
}

# 程序输出
Book 1 title : Go语言
Book 1 author : Tom
Book 1 subject : Go语言教程
Book 1 book_id : 6495407
Book 2 title : Python教程
Book 2 author : Marry
Book 2 subject : Python语言教程
Book 2 book_id : 6495700

1.3 结构体作为函数参数

你可以像其他数据类型一样将结构体类型作为参数传递给函数。

package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func main() {/* 声明 Book1 为 Books 类型 */var Book1 Books/* 声明 Book2 为 Books 类型 */var Book2 Books/* book 1 描述 */Book1.title = "Go语言"Book1.author = "Tom"Book1.subject = "Go语言教程"Book1.book_id = 6495407/* book 2 描述 */Book2.title = "Python教程"Book2.author = "Marry"Book2.subject = "Python语言教程"Book2.book_id = 6495700/* 打印 Book1 信息 */printBook(Book1)/* 打印 Book2 信息 */printBook(Book2)
}func printBook(book Books) {fmt.Printf("Book title : %s\n", book.title)fmt.Printf("Book author : %s\n", book.author)fmt.Printf("Book subject : %s\n", book.subject)fmt.Printf("Book book_id : %d\n", book.book_id)
}

# 程序输出
Book title : Go语言
Book author : Tom
Book subject : Go语言教程
Book book_id : 6495407
Book title : Python教程
Book author : Marry
Book subject : Python语言教程
Book book_id : 6495700

1.4 结构体指针

你可以定义指向结构体的指针类似于其他指针变量，格式如下：

var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：

struct_pointer = &Book1

使用结构体指针访问结构体成员，使用 . 操作符：

struct_pointer.title

实例：

package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func main() {var book = Books{"Go入门到放弃", "Tom", "go系列教程", 012231}var b *Booksb = &book// &{Go入门到放弃 Tom go系列教程 5273}fmt.Println(b)// {Go入门到放弃 Tom go系列教程 5273}fmt.Println(*b)// 0xc000006028fmt.Println(&b)// {Go入门到放弃 Tom go系列教程 5273}fmt.Println(book)
}

# b这个指针是Books类型的
var b *Books
# book是Books的一个实例化的结构,&book就是把这个结构体的内存地址赋给了b
b  = &book
# 那么在使用的时候,只要在b的前面加个*号,就可以把b这个内存地址对应的值给取出来了
*b
# 取了b这个指针的内存地址,也就是b这个指针是放在内存空间的什么地方的
&b
# 就是Books这个结构体,打印出来就是它自己,也就是指针b前面带了*号的效果
book

只有一个特殊的地方，尽管 b 所表示的是 book 对象的内存地址，但是，在从 b 对应的内存地址取属性值的时

候，就不是 *b.title 了。而是直接使用b.title，这点很特殊，它的效果就相当于 book.title：

package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func main() {var book = Books{"Go入门到放弃", "Tom", "go系列教程", 012231}var b *Booksb = &book// Go入门到放弃fmt.Println(b.title)// Go入门到放弃fmt.Println(book.title)// Tomfmt.Println(b.author)// Tomfmt.Println(book.author)
}

struct 类似于 java 中的类，可以在 struct 中定义成员变量。

要访问成员变量，可以有两种方式：

通过 struct 变量.成员 变量来访问。
通过 struct 指针.成员 变量来访问。

不需要通过 getter, setter 来设置访问权限。

package mainimport "fmt"// 定义矩形类
type Rect struct {// 类型只包含属性,并没有方法width, height float64
}// 为Rect类型绑定Area的方法,*Rect为指针引用可以修改传入参数的值
func (r *Rect) Area() float64 {// 方法归属于类型,不归属于具体的对象,声明该类型的对象即可调用该类型的方法return r.width * r.height
}func main() {var rect = Rect{3, 4}var p *Rect = &rectvar result = p.Area()// 12fmt.Println(result)
}

结构体是作为参数的值传递：

package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func changeBook(book Books) {book.title = "book1_change"
}func main() {var book1 Booksbook1.title = "go"book1.author = "tom"book1.book_id = 1changeBook(book1)// {go tom  1}fmt.Println(book1)
}

利用指针改变结构体对应的值：

package mainimport "fmt"type Books struct {title   stringauthor  stringsubject stringbook_id int
}func changeBook(book *Books) {book.title = "book1_change"
}func main() {var book1 Booksbook1.title = "go"book1.author = "tom"book1.book_id = 1changeBook(&book1)// {book1_change tom  1}fmt.Println(book1)
}

1.5 public 和 private属性

结构体中属性的首字母大小写问题：

首字母大写相当于 public。
首字母小写相当于 private。

这个 public 和 private 是相对于包（go 文件首行的 package 后面跟的包名）来说的。

当要将结构体对象转换为 JSON 时，对象中的属性首字母必须是大写，才能正常转换为 JSON。

package mainimport "fmt"
import "encoding/json"type Person struct {//Name字段首字母大写Name string//age字段首字母小写　　　　　age int
}func main() {person := Person{"小明", 18}//json.Marshal 将对象转换为json字符串if result, err := json.Marshal(&person); err == nil {// {"Name":"小明"}fmt.Println(string(result))}
}

package mainimport "fmt"
import "encoding/json"type Person struct {//Name字段首字母大写Name string//age字段首字母小写　　　　　Age int
}func main() {person := Person{"小明", 18}//json.Marshal 将对象转换为json字符串if result, err := json.Marshal(&person); err == nil {// {"Name":"小明","Age":18}fmt.Println(string(result))}
}

那这样 JSON 字符串以后就只能是大写了么？当然不是，可以使用 tag 标记要返回的字段名。

package mainimport "fmt"
import "time"
import "encoding/json"type Person struct {//标记json名字为nameName string `json:"name"`Age  int    `json:"age"`// 标记忽略该字段Time int64 `json:"-"`
}func main() {person := Person{"小明", 18, time.Now().Unix()}if result, err := json.Marshal(&person); err == nil {// {"name":"小明","age":18}fmt.Println(string(result))}
}

定义的结构体如果只在当前包内使用，结构体的属性不用区分大小写。如果想要被其他的包引用，那么结构体的属

性的首字母需要大写。

package book// 结构体小写开头的属性只能包内调用
type Books struct {Title   stringAuthor  stringSubject stringbook_id int
}

package mainimport ("fmt""proj/book"
)func main() {/* 声明 book 为 Books 类型 */var book book.Books/* book  描述 */book.Title = "Go语言"book.Author = "Tom"book.Subject = "Go语言教程"// 如果进行了如下调用，则会报错// book.book_id = 6495407/* 打印 book 信息 */printBook(book)
}func printBook(book book.Books) {fmt.Printf("Book title : %s\n", book.Title)fmt.Printf("Book author : %s\n", book.Author)fmt.Printf("Book subject : %s\n", book.Subject)// 无法调用// fmt.Printf( "Book book_id : %d\n", book.book_id)
}

# 程序输出
Book title : Go语言
Book author : Tom
Book subject : Go语言教程

1.6 struct{}和struct{}{}

一般我们知道struct在Go语言中是用于定义结构类型

type User struct {Name stringAge  int
}

而struct {}是一个无元素的结构体类型，通常在没有信息存储时使用。

优点是大小为0，不需要内存来存储 struct {} 类型的值。

struct {} {}是一个复合字面量，它构造了一个struct {}类型的值，该值也是空。

比如我们可以用map[string]struct{}来当作成一个set来用。

package mainimport "fmt"func main() {// 定义一个mapvar set map[string]struct{}set = make(map[string]struct{})// struct{}{}构造了一个struct{}类型的值set["red"] = struct{}{}value, ok := set["red"]// Is red in the map? truefmt.Println("Is red in the map?", ok)// {}fmt.Println(value)
}

输出内容：

# 程序输出
Is red in the map? true
{}

map可以通过comma ok机制来获取该key是否存在，value, ok := map["key"]，如果没有对应的值，ok为

false，这样可以通过定义成map[string]struct{}的形式，值不再占用内存。其值仅有两种状态，有或无。

其他知识点：

chan struct{}：可以用作通道的退出

// 1个goroutine
package mainimport ("fmt""time"
)func worker(name string, stopChan chan struct{}) {for {select {case <-stopChan:fmt.Println("receive a stop signal, ", name)returndefault:fmt.Println("I am worker ", name)time.Sleep(1 * time.Second)}}
}func main() {/*I am worker  aI am worker  areceive a stop signal,  a*/stopCh := make(chan struct{})go worker("tom", stopCh)time.Sleep(2 * time.Second)stopCh <- struct{}{}time.Sleep(1 * time.Second)
}

# 程序输出
I am worker  tom
I am worker  tom
receive a stop signal,  tom

package mainimport ("fmt""time"
)func worker(name string, stopchan chan struct{}) {for {select {case <-stopchan:fmt.Println("receive a stop signal, ", name)returndefault:fmt.Println("I am worker ", name)time.Sleep(1 * time.Second)}}
}func main() {stopCh := make(chan struct{})go worker("a", stopCh)go worker("b", stopCh)time.Sleep(2 * time.Second)stopCh <- struct{}{}time.Sleep(1 * time.Second)
}

# 程序输出
I am worker  b
I am worker  a
I am worker  b
I am worker  a
I am worker  b
receive a stop signal,  a
I am worker  b

也就是说a退出了，b没有退出，因为stopCh <- struct{}{}只发送一个信号，被a接收了，b不受影响。

如果想让2个goroutine同时退出，需要这样写：

package mainimport ("fmt""time"
)func worker(name string, stopchan chan struct{}) {for {select {case <-stopchan:fmt.Println("receive a stop signal, ", name)returndefault:fmt.Println("I am worker ", name)time.Sleep(1 * time.Second)}}
}func main() {stopCh := make(chan struct{})go worker("a", stopCh)go worker("b", stopCh)time.Sleep(2 * time.Second)close(stopCh)time.Sleep(1 * time.Second)
}

# 程序输出
I am worker  b
I am worker  a
I am worker  b
I am worker  a
receive a stop signal,  b
receive a stop signal,  a

两个struct{}{}地址相等

package mainimport "fmt"func main() {var s1 = struct{}{}var s2 = struct{}{}// truefmt.Printf("%t", s1 == s2)
}

1.7 组合

1.7.1 内嵌字段的初始化和访问

struct的字段访问使用点操作符.， struct的宇段可以嵌套很多层，只要内嵌的字段是唯一的即可，不需要使

用全路径进行访。在以下示例中，可以使用z.a代替，可以使用z.a代替z.Y.X.a。

package maintype X struct {a int
}type Y struct {Xb int
}type Z struct {Yc int
}func main() {x := X{a: 1}y := Y{X: x,b: 2,}z := Z{Y: y,c: 3,}// z.a, z.Y.a, z.Y.X.a 三者是等价的, z.a z.Y.a是z.Y.X.a的简写// 1 1 1println(z.a, z.Y.a, z.Y.X.a)z = Z{}z.a = 2// 2 2 2println(z.a, z.Y.a, z.Y.X.a)
}

在struct的多层嵌套中，不同嵌套层次可以有相同的字段，此时最好使用完全路径进行访问和初始化。在实际数

据结构的定义中应该尽量避开相同的字段，以免在使用中出现歧义。

package maintype X struct {a int
}type Y struct {Xa int
}type Z struct {Ya int
}func main() {x := X{a: 1}y := Y{X: x,a: 2,}z := Z{Y: y,a: 3,}// 此时的z.a, z.Y.a, z.Y.X.a 代表不同的字段// 3 2 1println(z.a, z.Y.a, z.Y.X.a)z = Z{}z.a = 4z.Y.a = 5z.Y.X.a = 6// 此时的z.a, z.Y.a, z.Y.X.a 代表不同的字段// 4 5 6println(z.a, z.Y.a, z.Y.X.a)
}

1.7.2 内嵌字段的方法调用

struct 类型方法调用也使用点操作符，不同嵌套层次的字段可以有相同的方法，外层变量调用内嵌字段的方法时也

可以像嵌套字段的访问一样使用简化模式。如果外层字段和内层字段有相同的方法，则使用简化模式访问外层的方

法会覆盖内层的方法。即在简写模式下，Go编译器优先从外向内逐层查找方法，同名方法中外层的方法能够覆盖

内层的方法。这个特性有点类似于面向对象编程中，子类覆盖父类的同名方法。

package mainimport "fmt"type X struct {a int
}type Y struct {Xb int
}type Z struct {Yc int
}func (x X) Print() {fmt.Printf("In X, a=%d\n", x.a)
}func (x X) XPrint() {fmt.Printf("In X, a=%d\n", x.a)
}func (y Y) Print() {fmt.Printf("In Y, b=%d\n", y.b)
}func (z Z) Print() {fmt.Printf("In Z, c=%d \n", z.c)//显式的完全路径调用内嵌字段的方法z.Y.Print()z.Y.X.Print()
}func main() {x := X{a: 1}y := Y{X: x,b: 2,}z := Z{Y: y,c: 3,}// 从外向内查找首先找到的是Z的Print()方法// In Z, c=3// In Y, b=2// In X, a=1z.Print()// 从外向内查找,最后找到的是X的XPrint()方法// In X, a=1z.XPrint()// In X, a=1z.Y.XPrint()
}

不推荐在多层的 struct类型中内嵌多个同名的字段；但是并不反对struct定义和内嵌字段同名方法的用法，因为这

提供了一种编程技术，使得 struct 能够重写内嵌字段的方法，提供面向对象编程中子类覆盖父类的同名方法的功

能。

1.8 组合的方法集

组合结构的方法集有如下规则：

(1)、若类型S包含匿名字段T，则S的方法集包含T的方法集。

(2)、若类型S包含匿名字段*T，则S的方法集包含T和*T方法集。

(3)、不管类型S中嵌入的匿名字段是T还是*T，*S方法集总是包含T 和*T方法集。

下面举个例子来验证这个规则的正确性，前面讲到方法集时提到Go编译器会对方法调用进行自动转换，为了阻止

自动转换，本示例使用方法表达式的调用方式，这样能更清楚地理解这个方法集的规约。

package maintype X struct {a int
}type Y struct {X
}type Z struct {*X
}func (x X) Get() int {return x.a
}func (x *X) Set(i int) {x.a = i
}func main() {x := X{a: 1}y := Y{X: x,}// 1println(y.Get())//此处编译器做了自动转换y.Set(2)// 2println(y.Get())//为了不让编译器做自动转换, 我们使用method expression格式调用(*Y).Set(&y, 3)// type Y的方法集合并没有Set这个方法, 所以下一句编译通不过// Y.Set(y, 3) // type Y has no method Set// 3println(y.Get())z := Z{X: &x,}//按照嵌套字段的方法集的规则//Z 内嵌字段*X,所以type Z和type *Z方法集都是 Get和Set//为了不让编译器做自动转换, 我们仍然使用method expression格式调用Z.Set(z, 4)// 4println(z.Get())(*Z).Set(&z, 5)// 5println(z.Get())}

# 程序输出
1
2
3
4
5

到目前为止还没有发现方法集有多大的用途，而且通过实践发现，Go编译器会进行自动转换，看起来不需要太关

注方法集，这种认识是错误的。编译器的自动转换仅适用于直接通过类型实例调用方法时才有效，类型实例传递给

接口时，编译器不会进行自动转换，而是会进行严格的方法集校验。

Go函数的调用实参都是值拷贝，方法调用参数传递也是一样的机制，具体类型变量传递给接口时也是值拷贝，如

果传递给接口变量的是值类型，但调用方法的接收者是指针类型，则程序运行时虽然能够将接收者转换为指针，但

这个指针是副本的指针，并不是我们期望的原变量的指针。所以语言设计者为了杜绝这种非期望的行为，在编译时

做了严格的方法集合的检查，不允许产生这种调用;如果传递给接口的变量是指针类型，则接口调用的是值类型的

方法，程序运行时能够自动转换为值类型，这种转换不会带来副作用，符合调用者的预期，所以这种转换是允许

的，而且这种情况符合方法集的规约。具体类型传递给接口时编译器会进行严格的方法集校验，掌握了方法集的概

念在后续章节学习接口时非常有用。

1.9 数组内嵌到 struct

package mainimport "fmt"func main() {a := [3]int{1, 2, 3}c := struct{ s [3]int }{s: a}// {[1 2 3]}fmt.Println(c.s)
}