pair

reflect 包

func main() {
	var a interface{}
	a = 10
	fmt.Println(a)

	// 类型断言
	value, ok := a.(int)
	if ok {
		fmt.Println(value)
	} else {
		fmt.Println("类型断言失败")
	}

	// 反射
	// 获取变量的类型
	fmt.Println(reflect.TypeOf(a)) // int
	// 获取变量的值
	fmt.Println(reflect.ValueOf(a)) // 10

	// 获取变量的类型
	typeOfA := reflect.TypeOf(a)
	fmt.Println(typeOfA.Name(), typeOfA.Kind()) // int int

	// 获取变量的值
	valueOfA := reflect.ValueOf(a)
	fmt.Println(valueOfA.Int()) // 10
}

• reflect.TypeOf() ：获取变量的类型
• reflect.TypeOf().Name() ：获取变量的类型，转换为 string 类型
• reflect.TypeOf().Kind() ：获取变量的类型，转换为枚举类型
• reflect.ValueOf() ：获取变量的值
• reflect.ValueOf().Int() ：获取变量的值，转换为 int 类型

更多反射的使用方法，参考 Go 语言反射 (opens new window)

结构体标签（类似注解）

type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

• 结构体标签的本质是一个字符串
• 结构体标签的格式： key:"value"
• 结构体标签的使用： reflect.TypeOf().Field().Tag.Get("key")

func main() {
	var a interface{}
	a = Person{"张三", 18}
	fmt.Println(a)

	// 反射
	// 获取变量的类型
	typeOfA := reflect.TypeOf(a)
	fmt.Println(typeOfA.Name(), typeOfA.Kind()) // Person struct

	// 获取变量的值
	valueOfA := reflect.ValueOf(a)
	fmt.Println(valueOfA.Field(0).String()) // 张三
	fmt.Println(valueOfA.Field(1).Int()) // 18

	// 获取结构体标签
	fmt.Println(typeOfA.Field(0).Tag.Get("json")) // name
	fmt.Println(typeOfA.Field(1).Tag.Get("json")) // age
}

应用场景：JSON 序列化

type Movie struct {
	Title  string `json:"title"`
	Year   int    `json:"year"`
	Price  int    `json:"rmb"`
	Actors []string `json:"actors"`
}

func main() {
	movie := Movie{
		Title:  "肖申克的救赎",
		Year:   1994,
		Price:  100,
		Actors: []string{"蒂姆·罗宾斯", "摩根·弗里曼", "鲍勃·冈顿"},
	}

	// 序列化 JSON字符串
	data, err := json.Marshal(movie)
	if err != nil {
		fmt.Println("序列化失败")
		return
	}
	fmt.Printf("%s\n", data)

	// 反序列化
	var movie2 Movie
	err = json.Unmarshal(data, &movie2)
	if err != nil {
		fmt.Println("反序列化失败")
		return
	}
	fmt.Println(movie2)
}

控制台输出：

{"title":"肖申克的救赎","year":1994,"rmb":100,"actors":["蒂姆·罗宾斯","摩根·弗里曼","鲍勃·冈顿"]}
{肖申克的救赎 1994 100 [蒂姆·罗宾斯 摩根·弗里曼 鲍勃·冈顿]}

应用场景：ORM

略