hello云胜

技术与生活

0%

发表于

结构体

作为C语言家族的一员，go和c一样也支持结构体。可以类比于java的一个POJO。

在学习定义结构体之前，先学习下定义一个新类型。

定义一个新类型

1
2
type T1 int
type T2 T1

新类型 T1 是基于 Go 原生类型 int 定义的新自定义类型，而新类型 T2 则是 基于刚刚定义的类型 T1，定义的新类型。

这里要引入一个底层类型的概念。

如果一个新类型是基于某个 Go 原生类型定义的， 那么我们就叫 Go 原生类型为新类型的底层类型

在上面的例子中，int就是T1的底层类型。

但是T1不是T2的底层类型，只有原生类型才可以作为底层类型，所以T2的底层类型还是int

底层类型的重要性

底层类型是很重要的，因为对两个变量进行显式的类型转换，只有底层类型相同的变量间才能相互转换。底层类型是判断两个类型本质上是否相同的根本。

类型别名

1
type T = string

这种类型定义方式通常用在 项目的渐进式重构，还有对已有包的二次封装方面

类型别名表示新类型和原类型完全等价，实际上就是同一种类型。只不过名字不同而已。

定义结构体的基本形式

1
2
3
4
5
6
// 定义结构体
type Employee struct {
	Id   string
	Name string
	Age  int
}

一般我们都是定义一个有名的结构体。

字段名的大小写决定了字段是否包外可用。只有大写的字段可以被包外引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 三种初始化的方式
func TestCreateObj(t *testing.T) {
	e := Employee{"001", "yunsheng", 32} // 省略字段名。不建议
	t.Log(e)

	e2 := Employee{Name: "World", Age: 66}
	t.Log(e2)

	e3 := new(Employee) // 返回指针
	e3.Age = 111
	t.Log(e3)

	// 三种方式创建的对象的类型
	t.Logf("e : %T", e)   // obj_test.Employee
	t.Logf("e2 : %T", e2) // obj_test.Employee
	t.Logf("e3 : %T", e3) // *obj_test.Employee
}

还有一个点提一下

1
e2 := Employee{Name: "World", Age: 66}

如果换行来写

1
2
3
4
e2 := Employee{
	Name: "World",
	Age:  66,
}

Age: 66,后面这个都好不能省略

还有一个点，观察e3的赋值

1
2
e3 := new(Employee) // 返回指针
e3.Age = 111

new返回的是一个指针。然后指针可以直接点号赋值。这说明go默认进行了取值操作

e3.Age等价于(*e3).Age

空结构体

1
2
3
type Empty struct {}
var e Empty
t.Log(unsafe.Sizeof(e))

如上定义了一个空的结构体Empty。打印了元素e的内存大小是0。

有什么用呢？

基于空结构体类型内存零开销这样的特性，我们在日常 Go 开发中会经常使用空 结构体类型元素，作为一种“事件”信息进行 Goroutine 之间的通信

这种以空结构体为元素类建立的 channel，是目前能实现的、内存占用最小的 Goroutine 间通信方式。

1
2
var c = make(chan Empty) // 声明一个元素类型为Empty的channel
c <- Empty{}             // 向channel写入一个“事件”

结构体的字段可以是另一个结构体

这种形式需要说的是几个语法糖。

1
2
3
4
5
6
7
8
9
type Reader struct {
	ReaderName string
	Age int
}

type Book struct {
	BookName string
	Reader Reader
}

语法糖1：

1
2
3
4
type Book struct {
	BookName string
	Reader
}

对于结构体字段，可以省略字段名，只写结构体名。默认字段名就是结构体名

这种方式称为 嵌入字段或者叫匿名字段

语法糖2：

如果是以嵌入字段形式写的结构体

1
2
3
4
reader := Reader{"yunsheng", 20}
book := Book{"禅与摩托车维修艺术", reader}
t.Log(book.Reader.ReaderName)
t.Log(book.ReaderName)

可以省略嵌入的Reader字段，而直接访问ReaderName

如果匿名字段有同名的字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
type A struct {
    a int
    b int
}

type B struct {
    b float32
    c string
    d string
}

type C struct {
    A
    B
    a string
    c string
}

规则(1)，直属于C的a和c会分别覆盖A.a和B.c。可以直接使用c.a、c.c分别访问直属于C中的a、c字段，使用c.d或c.B.d都访问属于嵌套的B.d字段。如果想要访问内部struct中被覆盖的属性，可以c.A.a的方式访问。

规则(2)，A和B在C中是同级别的嵌套结构，所以A.b和B.b是冲突的，将会报错，因为当调用c.b的时候不知道调用的是c.A.b还是c.B.b。

初始化问题

  1. 零值初始化

    1
    var book Book

此时book是一个各个属性全是对应类型零值的一个实例。不是nil。这种情况在Go中称为零值可用。不像java会导致npe

  1. 不建议使用字段顺序复制方式初始化

    如上面的代码是一个不好的示例

    1
    book := Book{"禅与摩托车维修艺术", reader}

    这样按字段顺序一个个复制的方式，问题很多：

    当定义的结构体字段顺序改变或者出现字段增删，必须跳转初始化的代码。或者出现非导出字段，这种方式也不支持。

    推荐使用“field:value”形式赋值初始化。

    1
    book := Book{BookName:"禅与摩托车维修艺术", Reader: reader}

字段标签

结构体定义时可以在字段后面追加标签说明。

1
2
3
4
5
type Employee struct {
	Id   string `json:"id"`
	Name string `json:"name"`
	Age  int `json:"age,omitempty"`
}

tag的格式为反单引号

1
key1:"value1" key2:"value2"

tag的作用是可以使用[反射]来检视字段的标签信息。

具体的作用还要看使用的场景。

比如这里的tag是为了帮助encoding/json标准包在解析对象时可以利用的规则。比如omitempty表示该字段没有值就不打印出来。