Go语言可以通过自定义的方式形成新的类型，结构体就是这些类型中的一种复合类型，结构体是由零个或多个任意类型的值聚合成的实体，每个值都可以称为结构体的成员。
结构体成员也可以称为“字段”，这些字段有以下特性：
- 字段拥有自己的类型和值；
- 字段名必须唯一；
- 字段的类型也可以是结构体，甚至是字段所在结构体的类型。
使用关键字 type 可以将各种基本类型定义为自定义类型，基本类型包括整型、字符串、布尔等。结构体是一种复合的基本类型，通过 type 定义为自定义类型后，使结构体更便于使用。
结构体的定义格式如下：
type 类型名 struct {
字段1 字段1类型
字段2 字段2类型
…
}
对各个部分的说明：
- 类型名：标识自定义结构体的名称，在同一个包内不能重复。
- struct{}：表示结构体类型，
type 类型名 struct{}可以理解为将 struct{} 结构体定义为类型名的类型。 - 字段1、字段2……：表示结构体字段名，结构体中的字段名必须唯一。
- 字段1类型、字段2类型……：表示结构体各个字段的类型。
结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存，因此必须在定义结构体并实例化后才能使用结构体的字段。
实例化就是根据结构体定义的格式创建一份与格式一致的内存区域，结构体实例与实例间的内存是完全独立的。
Go语言可以通过多种方式实例化结构体，根据实际需要可以选用不同的写法。
结构体本身是一种类型，可以像整型、字符串等类型一样，以 var 的方式声明结构体即可完成实例化。
基本实例化格式如下：
var ins T
其中，T 为结构体类型，ins 为结构体的实例。
用结构体表示的点结构（Point）的实例化过程请参见下面的代码：
type Point struct { X int Y int } var p Point p.X = 10 p.Y = 20
在例子中，使用.来访问结构体的成员变量，如p.X和p.Y等，结构体成员变量的赋值方法与普通变量一致。
指针类型的结构体:
Go语言中，还可以使用 new 关键字对类型（包括结构体、整型、浮点数、字符串等）进行实例化，结构体在实例化后会形成指针类型的结构体。
使用 new 的格式如下：
ins := new(T)
其中：
- T 为类型，可以是结构体、整型、字符串等。
- ins：T 类型被实例化后保存到 ins 变量中，ins 的类型为 *T，属于指针。
Go语言让我们可以像访问普通结构体一样使用.来访问结构体指针的成员。
下面的例子定义了一个玩家（Player）的结构，玩家拥有名字、生命值和魔法值，实例化玩家（Player）结构体后，可对成员进行赋值，代码如下：
type Player struct{ Name string HealthPoint int MagicPoint int } tank := new(Player) tank.Name = "Canon" tank.HealthPoint = 300
经过 new 实例化的结构体实例在成员赋值上与基本实例化的写法一致。
结构体在实例化时可以直接对成员变量进行初始化，初始化有两种形式分别是以字段“键值对”形式和多个值的列表形式，键值对形式的初始化适合选择性填充字段较多的结构体，多个值的列表形式适合填充字段较少的结构体。
使用“键值对”初始化结构体
结构体可以使用“键值对”（Key value pair）初始化字段，每个“键”（Key）对应结构体中的一个字段，键的“值”（Value）对应字段需要初始化的值。
键值对的填充是可选的，不需要初始化的字段可以不填入初始化列表中。
结构体实例化后字段的默认值是字段类型的默认值，例如 ，数值为 0、字符串为 ""（空字符串）、布尔为 false、指针为 nil 等。
1,键值对初始化结构体的书写格式
键值对初始化的格式如下：
ins := 结构体类型名{
字段1: 字段1的值,
字段2: 字段2的值,
…
}
下面是对各个部分的说明：
- 结构体类型：定义结构体时的类型名称。
- 字段1、字段2：结构体成员的字段名，结构体类型名的字段初始化列表中，字段名只能出现一次。
- 字段1的值、字段2的值：结构体成员字段的初始值。
键值之间以:分隔，键值对之间以,分隔。
2，使用键值对填充结构体的例子
下面示例中描述了家里的人物关联，正如儿歌里唱的：“爸爸的爸爸是爷爷”，人物之间可以使用多级的 child 来描述和建立关联，使用键值对形式填充结构体的代码如下：
type People struct { name string child *People } relation := &People{ name: "爷爷", child: &People{ name: "爸爸", child: &People{ name: "我", }, }, }
代码说明如下：
- 第 1 行，定义 People 结构体。
- 第 2 行，结构体的字符串字段。
- 第 3 行，结构体的结构体指针字段，类型是 *People。
- 第 6 行，relation 由 People 类型取地址后，形成类型为 *People 的实例。
- 第 8 行，child 在初始化时，需要 *People 类型的值，使用取地址初始化一个 People。
提示：结构体成员中只能包含结构体的指针类型，包含非指针类型会引起编译错误。
使用多个值的列表初始化结构体：
Go语言可以在“键值对”初始化的基础上忽略“键”，也就是说，可以使用多个值的列表初始化结构体的字段。
1，多个值列表初始化结构体的书写格式：
多个值使用逗号分隔初始化结构体，例如：
ins := 结构体类型名{
字段1的值,
字段2的值,
…
}
使用这种格式初始化时，需要注意：
- 必须初始化结构体的所有字段。
- 每一个初始值的填充顺序必须与字段在结构体中的声明顺序一致。
- 键值对与值列表的初始化形式不能混用。
2，多个值列表初始化结构体的例子
下面的例子描述了一段地址结构，地址要求具有一定的顺序，例如：
type Address struct { Province string City string ZipCode int PhoneNumber string } addr := Address{ "四川", "成都", 610000, "0", } fmt.Println(addr)
运行代码，输出如下：
{四川 成都 610000 0}
初始化匿名结构体：
匿名结构体没有类型名称，无须通过 type 关键字定义就可以直接使用。
匿名结构体定义格式和初始化写法
匿名结构体的初始化写法由结构体定义和键值对初始化两部分组成，结构体定义时没有结构体类型名，只有字段和类型定义，键值对初始化部分由可选的多个键值对组成，如下格式所示：
ins := struct { // 匿名结构体字段定义 字段1 字段类型1 字段2 字段类型2 … }{ // 字段值初始化 初始化字段1: 字段1的值, 初始化字段2: 字段2的值, … }
下面是对各个部分的说明：
- 字段1、字段2……：结构体定义的字段名。
- 初始化字段1、初始化字段2……：结构体初始化时的字段名，可选择性地对字段初始化。
- 字段类型1、字段类型2……：结构体定义字段的类型。
- 字段1的值、字段2的值……：结构体初始化字段的初始值。
使用匿名结构体的例子：
在本示例中，使用匿名结构体的方式定义和初始化一个消息结构，这个消息结构具有消息标示部分（ID）和数据部分（data），打印消息内容的 printMsg() 函数在接收匿名结构体时需要在参数上重新定义匿名结构体，代码如下：
package main import ( "fmt" ) // 打印消息类型, 传入匿名结构体 func printMsgType(msg *struct { id int data string }) { // 使用动词%T打印msg的类型 fmt.Printf("%T\n", msg) } func main() { // 实例化一个匿名结构体 msg := &struct { // 定义部分 id int data string }{ // 值初始化部分 1024, "hello", } printMsgType(msg) }
代码输出如下：
*struct { id int; data string }
代码说明如下：
- 第 8 行，定义 printMsgType() 函数，参数为 msg，类型为
*struct{id int data string}，因为类型没有使用 type 定义，所以需要在每次用到的地方进行定义。 - 第 14 行，使用字符串格式化中的
%T动词，将 msg 的类型名打印出来。 - 第 20 行，对匿名结构体进行实例化，同时初始化成员。
- 第 21 和 22 行，定义匿名结构体的字段。
- 第 24 和 25 行，给匿名结构体字段赋予初始值。
- 第 28 行，将 msg 传入 printMsgType() 函数中进行函数调用。
匿名结构体的类型名是结构体包含字段成员的详细描述，匿名结构体在使用时需要重新定义，造成大量重复的代码，因此开发中较少使用。
构造函数
Go语言的类型或结构体没有构造函数的功能，但是我们可以使用结构体初始化的过程来模拟实现构造函数。
下来我们来模拟下构造函数：
例子一：
type Cat struct { Color string Name string } func NewCatByName(name string) *Cat { return &Cat{ Name: name, } } func NewCatByColor(color string) *Cat { return &Cat{ Color: color, } }
代码说明如下：
- 第 1 行定义 Cat 结构，包含颜色和名字字段。
- 第 6 行定义用名字构造猫结构的函数，返回 Cat 指针。
- 第 7 行取地址实例化猫的结构体。
- 第 8 行初始化猫的名字字段，忽略颜色字段。
- 第 12 行定义用颜色构造猫结构的函数，返回 Cat 指针。
构造父子关系的的构造函数：
type Cat struct { Color string Name string } type BlackCat struct { Cat // 嵌入Cat, 类似于派生 } // “构造基类” func NewCat(name string) *Cat { return &Cat{ Name: name, } } // “构造子类” func NewBlackCat(color string) *BlackCat { cat := &BlackCat{} cat.Color = color return cat }
代码说明如下：
- 第 6 行，定义 BlackCat 结构，并嵌入了 Cat 结构体，BlackCat 拥有 Cat 的所有成员，实例化后可以自由访问 Cat 的所有成员。
- 第 11 行，NewCat() 函数定义了 Cat 的构造过程，使用名字作为参数，填充 Cat 结构体。
- 第 18 行，NewBlackCat() 使用 color 作为参数，构造返回 BlackCat 指针。
- 第 19 行，实例化 BlackCat 结构，此时 Cat 也同时被实例化。
- 第 20 行，填充 BlackCat 中嵌入的 Cat 颜色属性，BlackCat 没有任何成员，所有的成员都来自于 Cat。
这个例子中，Cat 结构体类似于面向对象中的“基类”，BlackCat 嵌入 Cat 结构体，类似于面向对象中的“派生”，实例化时，BlackCat 中的 Cat 也会一并被实例化。
总之，Go语言中没有提供构造函数相关的特殊机制，用户根据自己的需求，将参数使用函数传递到结构体构造参数中即可完成构造函数的任务。
结构体内嵌：
同样地结构体也是一种数据类型，所以它也可以作为一个匿名字段来使用，如同上面例子中那样。外层结构体通过 outer.in1 直接进入内层结构体的字段，内嵌结构体甚至可以来自其他包。内层结构体被简单的插入或者内嵌进外层结构体。这个简单的“继承”机制提供了一种方式，使得可以从另外一个或一些类型继承部分或全部实现。
package main import "fmt" type A struct { ax, ay int } type B struct { A bx, by float32 } func main() { b := B{A{1, 2}, 3.0, 4.0} fmt.Println(b.ax, b.ay, b.bx, b.by) fmt.Println(b.A) }
运行结果如下所示：
1 2 3 4
{1 2}
结构内嵌特性：
Go语言的结构体内嵌有如下特性。
1) 内嵌的结构体可以直接访问其成员变量
嵌入结构体的成员，可以通过外部结构体的实例直接访问。如果结构体有多层嵌入结构体，结构体实例访问任意一级的嵌入结构体成员时都只用给出字段名，而无须像传统结构体字段一样，通过一层层的结构体字段访问到最终的字段。例如，ins.a.b.c的访问可以简化为ins.c。
2) 内嵌结构体的字段名是它的类型名
内嵌结构体字段仍然可以使用详细的字段进行一层层访问，内嵌结构体的字段名就是它的类型名，代码如下：
var c Color c.BasicColor.R = 1 c.BasicColor.G = 1 c.BasicColor.B = 0
一个结构体只能嵌入一个同类型的成员，无须担心结构体重名和错误赋值的情况，编译器在发现可能的赋值歧义时会报错。
