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)
}
801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
