Go语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体定义需要使用type和struct语句。struct语句定义一个新的数据类型，结构体中有一个或多个成员。
type语句设定了结构体的名称。格式如下：
type struct_name struct {
name string
talk Talk
}
一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：
variable_name := structure_name{value1,value2} //顺序必须与结构体的定义一致
或者：
variable_name := structure_name{key1:value1,key2:value2} //结构体名称：值
结构体类型中的每个字段都需要独占一行。一般情况下，字段声明需由字段名称和表示字段类型的字面量组成。
还有一种只有类型字面量的无名称字段，称为嵌入字段。
虽然嵌入字段可以用来无缝集成额外字段和方法，但是其嵌入规则和使用规则都比较复杂。
结构体类型的值一般由复合字面量来表达。
复合字面量可以由类型字面量和花括号包裹的键值对列表组成。
这里，键就是结构体类型中某个字段的名称，而值（又称元素）就是要赋给该字段的那个值。
表示结构体值的复合字面量可以简称为结构体字面量。
在同一个结构体字面量中，一个字段名称只能出现一次。
字段名必须唯一,可用"_"补位,支持使用自身指针类型成员.
字段名,排列顺序属于类型组成部分.除对齐处理外,编译器不会优化和调整内存布局。
package main
import "fmt"
type node struct {
_ int //没给值会使用默认值
id int
next *node
}
func main() {
n1 := node{
id: 1,
}
n2 := node{
id: 2,
next: &n1,
}
fmt.Println(n1, n2) //{0 1 <nil>} {0 2 0xc000048400}
}
可按顺序初始化全部字段,或使用命名方式初始化指定字段。
package main
import "fmt"
func main() {
type user struct {
name string
age int
}
u1 := user{"Tom", 12} //如果顺序初始化字段,就必须赋值全部字段
u2 := user{"Kebi"} //too few values in user literal,字段数量不够
u3 := user{ //命名初始化
name: "maoixan",
age: 18,
}
fmt.Println(u1, u3)
}
推荐使用命名初始化,这样在扩充结构字段或调整字段顺序时,不会导致语句初始化错误.
可以直接匿名结构类型变量，还可以将结构体用作字段类型。
package main
import "fmt"
func main() {
u := struct { //直接定义匿名结构变量
name string
age int8
}{
name: "kebi",
age: 18,
}
type file struct {
name string
attr struct { //定义匿名结构类型字段
owner int
perm int
}
}
f := file{
name: "test.py",
// attr: { //missing type in composite literal,对于结构体中的结构体赋值方式有所不同
// owner: 10,
// perm: 755,
// },
}
f.attr.owner = 10 //正确方式
f.attr.perm = 755
fmt.Println(u, f) //{kebi 18} {test.py {10 755}}
}
只有在所有字段类型全部支持时，才可做相等操作。
package main
import "fmt"
func main() {
type data struct {
x int
y map[string]int //字典类型不支持==,
}
d1 := data{
x: 100,
}
d2 := data{
x: 100,
}
fmt.Println(d1 == d2) //struct containing map[string]int cannot be compared
}
可使用指针直接操作结构字段，但不能是多级指针。
package main
import "fmt"
func main() {
type user struct {
name string
age int
}
p := &user{ //获取指针
name: "kebi",
age: 26,
}
p.name = "maoxian" //通过指针找到对应的程序实体
p.age++
fmt.Println(p) //&{maoxian 27}
p2 := &p //&p属于二级指针
*p2.name = "xiaoniao" //p2.name undefined (type **user has no field or method name)
}
空结构
空结构struct{}是指没有字段的结构类型。
它比较特殊，因为无论是其自身，还是作为数组元素类型，其长度都为0。
package main
import (
"fmt"
"unsafe"
)
func main() {
var a struct{} //匿名结构体
var b [100]struct{} //以结构体作为元素类型的数组
fmt.Println(unsafe.Sizeof(a), unsafe.Sizeof(b)) //0 0
s := b[:]
b[1] = struct{}{} //重新赋值
s[2] = struct{}{}
fmt.Println(s[3], len(s), cap(s)) //{} 100 100
}
实际上，这类长度为0的对象通常指向runtime.zerobase变量。
package main
import "fmt"
func main() {
a := [10]struct{}{}
b := a[:]
c := [0]int{}
fmt.Printf("%p, %p, %p\n", &a[0], &b[0], &c) //0x5771c8, 0x5771c8, 0x5771c8
}
空结构可作为通道元素类型，用于事件通知。
package main
import "fmt"
func main() {
exit := make(chan struct{})
go func() {
fmt.Println("hello, world!")
exit <- struct{}{}
}()
<-exit
fmt.Println("end.")
}
匿名字段
所谓匿名字段是指没有名字，仅有类型的字段，也称作嵌入字段或嵌入类型。
从编译器角度看，这只是隐式地以类型名作为字段名称。
可直接引用匿名字段的成员，但初始化时必须当作独立字段。
package main
import "fmt"
type attr struct {
perm int
}
type file struct {
name string
attr //仅有类型名
}
func main() {
f := file{
name: "test.dat",
attr: attr{ //将类型名当作字段名
perm: 755,
},
}
f.perm = 500 //直接设置匿名字段成员
fmt.Println(f, f.perm) //直接读取匿名字段成员
}
如果嵌入其它包中的类型，则隐式字段名称不包括包名。
不仅仅是结构体，除接口指针和多级指针以外的任何命名类型都可以作为匿名字段。
package main
import "fmt"
type data struct {
*int //嵌入指针类型
string
}
func main() {
x := 100
d := data{
int: &x, //使用基础类型作为字段名
string: "abc",
}
fmt.Printf("%#v\n", d)
}
/*
main.data{
int:(*int)(0xc00000a168),
string:"abc"
}
*/
不能将基础类型和其指针类型同时嵌入，因为两者隐式名字相同,下面就是错误示例。
// type data struct {
// *int
// int
// }
虽然可以像普通字段那样访问匿名字段成员，但会存在重名问题。
默认情况下，编译器从当前显式命名开始，逐步向内查找匿名字段成员。
如果匿名字段成员被外层同名字段遮蔽，那么必须使用显式字段名。
package main
import "fmt"
type file struct {
name string
}
type data struct {
file
name string //与匿名字段file.name重名
}
func main() {
d := data{
name: "data",
file: file{"file"}, //这种方式赋值并没有影响
}
fmt.Println(d.name, d.file.name) //data file
d.name = "data2"
d.file.name = "file2"
fmt.Println(d.name, d.file.name) //data2 file2
}
如果多个相同层级的匿名字段成员重名，就只能使用显式字段名访问，因为编译器无法确定目标。
package main
import "fmt"
type file struct {
name string
}
type log struct {
name string
}
type data struct {
file //file和log层次相同
log //file.name和log.name重名
}
func main() {
d := data{
file: file{"1.txt"},
log: log{"test.log"},
}
fmt.Println(d) //{{1.txt} {test.log}}
d2 := data{}
// d2.name = "name" //ambiguous selector d2.name
d2.file.name = "file" //显式命名字段
d2.log.name = "log"
fmt.Println(d2) //{{file} {log}}
}
严格说来，Go并不是传统意义上的面向对象编程语言，或者说仅实现了最小面向对象的机制。
匿名嵌入不是继承，无法实现多态处理。
虽然配合方法集，可用接口来显现一些类似的操作，但其本质完全不同。
字段标签
字段标签（tag）并不是注释，而是用来对字段进行描述的元数据。
尽管它不属于数据成员，但却是类型的组成部分。
在运行期，可以反射获取标签信息。常被用作格式校验，数据库关系映射等。
package main
import (
"fmt"
"reflect"
)
type user struct {
name string `昵称`
sex int `性别`
}
func main() {
u := user{"Tom", 1}
v := reflect.ValueOf(u)
t := v.Type()
for i, n := 0, t.NumField(); i < n; i++ {
fmt.Printf("%s: %v\n", t.Field(i).Tag, v.Field(i))
}
}
/*
昵称: Tom
性别: 1
*/