Go 语言结构体

1、Go 语言结构体

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

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

1.1 定义结构体

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

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

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

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

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

package main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_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 main

import "fmt"

type Person struct {
	name string
	age  int
}

func main() {
	// 使用new创建内置函数,宇段默认初始化为其类型的零值,返回值是指向结构的指针
	p := new(Person)
	p.name = "tom"
	p.age = 27
	fmt.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 main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_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 main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_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 main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_id int
}

func main() {
	var book = Books{"Go入门到放弃", "Tom", "go系列教程", 012231}
	var b *Books
	b = &book
	// &{Go入门到放弃 Tom go系列教程 5273}
	fmt.Println(b)
	// {Go入门到放弃 Tom go系列教程 5273}
	fmt.Println(*b)
	// 0xc000006028
	fmt.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 main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_id int
}

func main() {
	var book = Books{"Go入门到放弃", "Tom", "go系列教程", 012231}
	var b *Books
	b = &book
	// Go入门到放弃
	fmt.Println(b.title)
	// Go入门到放弃
	fmt.Println(book.title)
	// Tom
	fmt.Println(b.author)
	// Tom
	fmt.Println(book.author)
}

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

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

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

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

package main

import "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 = &rect
	var result = p.Area()
	// 12
	fmt.Println(result)
}

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

package main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_id int
}

func changeBook(book Books) {
	book.title = "book1_change"
}

func main() {
	var book1 Books
	book1.title = "go"
	book1.author = "tom"
	book1.book_id = 1
	changeBook(book1)
	// {go tom  1}
	fmt.Println(book1)
}

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

package main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_id int
}

func changeBook(book *Books) {
	book.title = "book1_change"
}

func main() {
	var book1 Books
	book1.title = "go"
	book1.author = "tom"
	book1.book_id = 1
	changeBook(&book1)
	// {book1_change tom  1}
	fmt.Println(book1)
}

1.5 public 和 private属性

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

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

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

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

package main

import "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 main

import "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 main

import "fmt"
import "time"
import "encoding/json"

type Person struct {
	//标记json名字为name
	Name 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   string
	Author  string
	Subject string
	book_id int
}

package main

import (
	"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 string
    Age  int
}

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

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

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

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

package main

import "fmt"

func main() {
	// 定义一个map
	var set map[string]struct{}
	set = make(map[string]struct{})
	// struct{}{}构造了一个struct{}类型的值
	set["red"] = struct{}{}
	value, ok := set["red"]
	// Is red in the map? true
	fmt.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 main

import (
	"fmt"
	"time"
)

func worker(name string, stopChan chan struct{}) {
	for {
		select {
		case <-stopChan:
			fmt.Println("receive a stop signal, ", name)
			return
		default:
			fmt.Println("I am worker ", name)
			time.Sleep(1 * time.Second)
		}
	}
}

func main() {
	/*
		I am worker  a
		I am worker  a
		receive 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 main

import (
	"fmt"
	"time"
)

func worker(name string, stopchan chan struct{}) {
	for {
		select {
		case <-stopchan:
			fmt.Println("receive a stop signal, ", name)
			return
		default:
			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 main

import (
	"fmt"
	"time"
)

func worker(name string, stopchan chan struct{}) {
	for {
		select {
		case <-stopchan:
			fmt.Println("receive a stop signal, ", name)
			return
		default:
			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 main

import "fmt"

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

1.7 组合

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

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

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

package main

type X struct {
	a int
}

type Y struct {
	X
	b int
}

type Z struct {
	Y
	c 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 1
	println(z.a, z.Y.a, z.Y.X.a)
	z = Z{}
	z.a = 2
	// 2 2 2
	println(z.a, z.Y.a, z.Y.X.a)
}

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

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

package main

type X struct {
	a int
}

type Y struct {
	X
	a int
}

type Z struct {
	Y
	a 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 1
	println(z.a, z.Y.a, z.Y.X.a)
	z = Z{}
	z.a = 4
	z.Y.a = 5
	z.Y.X.a = 6
	// 此时的z.a, z.Y.a, z.Y.X.a 代表不同的字段
	// 4 5 6
	println(z.a, z.Y.a, z.Y.X.a)
}

1.7.2 内嵌字段的方法调用

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

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

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

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

package main

import "fmt"

type X struct {
	a int
}

type Y struct {
	X
	b int
}

type Z struct {
	Y
	c 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=1
	z.Print()
	// 从外向内查找,最后找到的是X的XPrint()方法
	// In X, a=1
	z.XPrint()
	// In X, a=1
	z.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 main

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

	// 1
	println(y.Get())

	//此处编译器做了自动转换
	y.Set(2)
	// 2
	println(y.Get())

	//为了不让编译器做自动转换, 我们使用method expression格式调用
	(*Y).Set(&y, 3)

	// type Y的方法集合并没有Set这个方法, 所以下一句编译通不过
	// Y.Set(y, 3) // type Y has no method Set
	// 3
	println(y.Get())

	z := Z{
		X: &x,
	}

	//按照嵌套字段的方法集的规则
	//Z 内嵌字段*X,所以type Z和type *Z方法集都是 Get和Set
	//为了不让编译器做自动转换, 我们仍然使用method expression格式调用
	Z.Set(z, 4)
	// 4
	println(z.Get())

	(*Z).Set(&z, 5)
	// 5
	println(z.Get())

}

# 程序输出
1
2
3
4
5

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

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

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

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

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

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

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

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

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

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

1.9 数组内嵌到 struct

package main

import "fmt"

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