package main

import (
	"encoding/json"
	"fmt"
)

// 复习结构体

type tmp struct { // 有名字的结构体
	x int
	y int
}

type person struct {
	name string
	age  int
}

// func sum(x int, y int) int {
func sum(x int, y int) (ret int) {
	// return x + y
	ret = x + y
	return ret
}

// 构造（结构体变量的）函数 返回值是对应的结构体类型
func newPerson(name string, age int) person {
	return person{
		name: name,
		age:  age,
	}
}

// 方法
// 接收者使用对应类型的首字母小写
// 指定了接收者之后，只有接收者这个类型的变量才能调用这个方法
func (p person) dream(str string) { // 接收者 对应类型首字母的小写
	fmt.Printf("%s的梦想是学好Go语言!\n", p.name)
	fmt.Printf("%s的梦想是%s!\n", p.name, str)
}

// func (p person) guonian() {
// 	p.age++ // 此处的p是p1的副本 修改的是副本
// }

// 指针接收者
// 1. 需要修改结构体变量的值时要使用指针接收者
// 2. 结构体本身比较大，拷贝的内存开销比较大时也要使用指针接收者
// 3. 保持一致性：如果有一个方法使用了指针接收者，其他的方法为了统一也要使用指针接收者
func (p *person) guonian() {
	p.age++ // 此处的p是p1的副本 修改的是副本
}

func main() {
	var a = struct { // 匿名结构体（没有名字的结构体）
		x int
		y int
	}{10, 20}
	fmt.Println(a)

	var b = tmp{
		x: 10,
		y: 20,
	}
	fmt.Println(b)

	var c = tmp{
		10,
		30,
	}
	fmt.Println(c)

	var x int
	y := int8(10)
	fmt.Println(x, y)

	var p1 person // 结构体实例化
	p1.name = "小花"
	p1.age = 13

	p2 := person{"李昕", 12} // 结构体实例化
	p3 := person{"紫霞", 18}

	// 调用构造函数生成person类型变量
	p4 := newPerson("貂蝉", 16)
	fmt.Println(p1, p2, p3, p4)
	p1.dream("做个咸鱼") // 方法向函数一样传参数
	p2.dream("学好Go语言")

	fmt.Println(p1.age) // 13
	p1.guonian()
	fmt.Println(p1.age) // 13 14

	// 结构体嵌套
	type addr struct {
		provice string
		city    string
	}

	type student struct {
		// 名称 类型
		name string
		// address addr // 嵌套别的结构体
		addr // 匿名嵌套别的结构体，就使用类型名做名称
	}
	type point struct {
		X int `json:"x"`
		Y int `json:"y"`
	}
	po1 := point{100, 200}
	// 序列化
	b1, err := json.Marshal(po1)
	// 如果出错了
	if err != nil {
		fmt.Printf("Marshal failed err:%v\n", err)
		return
	}
	fmt.Println(string(b1))
	// 反序列化 由字符串 --> Go中的结构体变量
	str1 := `{"x":12,"y":16}`
	var po2 point // 造一个结构体变量，准备接收反序列化的值
	err = json.Unmarshal([]byte(str1), &po2)
	if err != nil {
		fmt.Printf("Unmarshal failed err:%v\n", err)
		return
	}
	fmt.Println(po2)
    
	// map
	m1 := map[int64]string{
		10010: "王昭君",
		10020: "西施",
	}
	name := m1[10010]
	name1 := m1[10011]
	fmt.Println(name)
	fmt.Println(name1)     // 如果不存在返回对应类型的零值 取不到就返回value类型的零值
	name2, ok := m1[10030] // 如果ok=true表示有这个key，如果ok=false表示没有这个key
	fmt.Println(name2, ok)
	for k, v := range m1 {
		fmt.Println(k, v)
	}
	for k := range m1 {
		fmt.Println(k)
	}
}