Go语言入门（一）之 结构体

类型别名 & 自定义类型

自定义类型

type MyInt int  //将MyInt定义为int类型

通过type关键字的定义，MyInt就是一种新的类型，它具有int的特性，但却不是int了。

---

类型别名

type byte = uint8  //byte 是uint8 的别名
type rune = int32  //rune 是int32 的别名

只是换了个名字（换汤不换药），byte 就是 uint8 。

---

结构体

• Go语言中通过struct结构体来实现面向对象。
• 只有当结构体实例化时，才会真正地分配内存。
• 没有初始化的结构体，其成员变量都是对应其类型的零值。
• 任何类型都可以拥有方法，包括int、string等
• 结构体内可以有匿名字段，这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名。
  结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

1️⃣ 定义结构体

type person struct {
	name string
	city string
	age  int8
}

2️⃣ 实例化结构体的四种方法

var hxt person 

var hxt2 = new(person)  //hxt2是结构体指针

var user struct{Name string; Age int}//匿名结构体实例化

//使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
hxt3 := &person{}  //hxt3.name = "zncu" 其实在底层是(*p3).name = "zncu"（就是语法糖：用更简练的言语表达较复杂的含义）

3️⃣ 结构体初始化

//键值对初始化
hxt4 := person{
	name: "小王子",
	city: "北京",
	age:  18,
}

//使用结构体指针进行键值对初始化
hxt5 := &person{
	name: "小王子",
	city: "北京",
	age:  18,
}

4️⃣ 结构体内存布局

• 结构体占用一块连续的内存。
• 空结构体是不占用空间的。
• ⭐️go语言中内存对齐

5️⃣ 构造函数
因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

func newPerson(name, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}

6️⃣ 方法和接受者

方法

//方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    函数体
}

其中:

• 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
• 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
• 方法名、参数列表、返回参数：具体格式与函数定义相同。

举个栗子：

//Person 结构体
type Person struct {
	name string
	age  int8
}

//NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}

//Dream Person做梦的方法
func (p Person) Dream() {
	fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
}

func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
}

---

指针类型的接收者

• 指针类型的接收者由一个 结构体的指针 组成
• 由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
• 这种方式就十分接近于其他语言中面向对象中的this或者self。

例如我们为Person添加一个SetAge方法，来修改实例变量的年龄。

// SetAge 设置p的年龄
// 使用指针接收者
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}
调用该方法：

func main() {
	p1 := NewPerson("小王子", 25)
	fmt.Println(p1.age) // 25
	p1.SetAge(30)
	fmt.Println(p1.age) // 30
}

---

值类型的接收者

• 当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。
• 在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。

// SetAge2 设置p的年龄
// 使用值接收者
func (p Person) SetAge2(newAge int8) {
	p.age = newAge
}

func main() {
	p1 := NewPerson("小王子", 25)
	p1.Dream()
	fmt.Println(p1.age) // 25
	p1.SetAge2(30) // (*p1).SetAge2(30)
	fmt.Println(p1.age) // 25
}

---

什么时候应该使用指针类型接收者

• 需要修改接收者中的值
• 接收者是拷贝代价比较大的大对象
• 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。

---

7️⃣ 结构体的继承

//Animal 动物
type Animal struct {
	name string
}

func (a *Animal) move() {
	fmt.Printf("%s会动！\n", a.name)
}

//Dog 狗
type Dog struct {
	Feet    int8
	*Animal //通过嵌套匿名结构体实现继承
}

func (d *Dog) wang() {
	fmt.Printf("%s会汪汪汪~\n", d.name)
}

func main() {
	d1 := &Dog{
		Feet: 4,
		Animal: &Animal{ //注意嵌套的是结构体指针
			name: "乐乐",
		},
	}
	d1.wang() //乐乐会汪汪汪~
	d1.move() //乐乐会动！
}

8️⃣ 结构体与JSON序列化

//Student 学生
type Student struct {
	ID     int
	Gender string
	Name   string
}

//Class 班级
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 10; i++ {
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}
	//JSON序列化：结构体-->JSON格式的字符串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n", data)
	//JSON反序列化：JSON格式的字符串-->结构体
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

9️⃣ 结构体标签（Tag）

• Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。
• Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：

`key1:"value1"  key2:"value2"`

• 结构体tag由一个或多个键值对组成。
• 键与值使用冒号分隔，值用双引号括起来。
• 同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。

⭐️注意： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。

举个栗子：我们为Student结构体的每个字段定义json序列化时使用的Tag：

//Student 学生
type Student struct {
	ID     int    `json:"id"` //通过指定tag实现json序列化该字段时的key，相当于是把ID重命名为id
	Gender string //json序列化是默认使用字段名作为key
	name   string //私有不能被json包访问
}

func main() {
	s1 := Student{
		ID:     1,
		Gender: "男",
		name:   "沙河娜扎",
	}
	data, err := json.Marshal(s1)
	if err != nil {
		fmt.Println("json marshal failed!")
		return
	}
	fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}

⭐️注意：因为slice和map这两种数据类型都包含了指向底层数据的指针，因此我们在需要复制它们时要特别注意。

type Person struct {
	name   string
	age    int8
	dreams []string
}

func (p *Person) SetDreams(dreams []string) {
	p.dreams = dreams
}

func main() {
	p1 := Person{name: "小王子", age: 18}
	data := []string{"吃饭", "睡觉", "打豆豆"}
	p1.SetDreams(data)

	// 你真的想要修改 p1.dreams 吗？
	data[1] = "不睡觉"
	fmt.Println(p1.dreams)  // ?
}

正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值。

func (p *Person) SetDreams(dreams []string) {
	p.dreams = make([]string, len(dreams))
	copy(p.dreams, dreams)
}

同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题。