go学习 --- 结构体

一、入门练习

1、结构体是自定义的数据类型，代表一类事物

2、结构体变量(实例)是具体的，实际的，代表一个具体变量

3、字段是结构体的一个组成部分，一般是基本数据类型、数组，也可是引用类型。

package main

import "fmt"

//定义一个结构体
type  Cat struct {
	Name string
	Age int
	love string
}


func main() {
	//使用结构体
	cat1 := Cat{
		"花花",
		18,
		"毛线球",
	}
	cat2 := Cat{
		Name: "球球",
		Age:  12,
		love: "🐟",
	}
    var arr [5]interface{}
	arr[0] = cat1
	arr[1] = cat2
	for _, value := range arr {
		fmt.Println(value)
	}
}

 二、结构体内存图

 三、结构体属性注意事项

package main

import "fmt"

type Test struct {
	Name string
	Age int
	ptr *int
	slice []int
	map1 map[string]string
}
func main() {
	//要先make才能使用
	ints := make([]int, 5)
	strings := make(map[string]string)
	ints[0] = 1
	strings["hhh"] = "jjj"
	test := Test{
		Name:  "小花",
		Age:   2,
		ptr:   nil,
		slice: ints,
		map1:  strings,
	}
	fmt.Println(test)
}

 四、结构体的四种使用

package main

import "fmt"

type Cat struct {
	Name string
	Age int
}
func main() {
	//第一种
	var cat1 Cat
	cat1.Name = "小花"
	cat1.Age = 1
	fmt.Println(cat1)
	//第二种
	cat2 := Cat{
		"小白",
		5,
	}
	fmt.Println(cat2)
	//第三种
	var cat3 *Cat = new(Cat)
	//(*cat3).Name = "小球"
	//(*cat3).Age = 2
	cat3.Name = "小球"
	cat3.Age = 2
	fmt.Println(*cat3)
	//第四种
	var cat4 *Cat = &Cat{"球球",4}
	//(*cat4).Name = "球球"
	//(*cat4).Age = 3
	//cat4.Name = "球球"
	//cat4.Age = 3
	fmt.Println(*cat4)
}

 五、结构体注意事项

package main

import "fmt"

//定义一个结构体
type Point struct {
	x int
	y int
}
type Rect struct {
	//leftUp Point
	//rightDown Point
	leftUp,rightDown Point
}

func main() {
	point := Rect{Point{ 1,2}, Point{2, 2}}
	fmt.Println(point)
}

2、结构体是用户单独定义的类型,和其它类型进行转换时需要有完全相同的字段(名字、个数和类型）

package main

import "fmt"

//定义一个结构体
type A struct {
	Num int
}
type B struct {
	Num int
}

func main() {
	a := A{}
	b := B{}
	//将B结构体转换为A
	a = A(b)
	fmt.Println(a,b)
}

 3、结构体进行type重新定义(相当于取别名)，Golang认为是新的数据类型，但是相互间可以强转

package main

import "fmt"

type Student struct {
	Name string
}
type stu Student
func main() {
	stu1 := Student{"小马"}
	stu2 := stu{}
	stu2 = stu(stu1)
   fmt.Println(stu1,stu2)
}

 4、struct的每个字段上，可以写上一个tag, 该tag可以通过反射机制获取，常见的使用场景就是序列化和反序列化。

package main

import (
	"encoding/json"
	"fmt"
)

//定义一个结构体
type Monster struct {
	Name string `json:"name"`
	Age int `json:"age"`
}

func main() {
	monster := Monster{
		"老牛",
		52,
	}
	bytes, err := json.Marshal(monster)
	if err != nil {
		fmt.Println("转换错误")
	} else {
		fmt.Println(string(bytes))
	}
}