GO语言学习之路20

2022/02/11   //舒适的环境很难培养出坚强的品格，被安排好的人生也很难做出伟大的事业


package main

import (
	"encoding/json"
	"fmt"
)

type Monster struct {
	Name     string `json:"name"`
	Age      int
	Birthday string
	Sal      float64
	Skill    string
}

/*
	func Marshal(v interface{}) ([]byte, error)
	Marshal函数返回v的json编码。

	反序列化一个json字符串时，
	确保反序列化后的数据类型和原来序列化前的数据类型一致
*/

func testStruct() {
	/*
		1.把结构体序列化
	*/
	monster := Monster{
		Name:     "牛魔王",
		Age:      500,
		Birthday: "20220211",
		Sal:      1000.0,
		Skill:    "牛魔拳",
	}
	data, err := json.Marshal(monster)
	if err != nil {
		fmt.Println("序列化错误", err)
	}
	fmt.Println(string(data))

	//data是序列化的格式，接下来把data反序列化
	/*
		2.把结构体反序列化
	*/
	var monster2 Monster
	err2 := json.Unmarshal(data, &monster2)
	if err2 != nil {
		fmt.Println("反序列化失败", err)
		return
	}
	fmt.Println("反序列化成功")
	fmt.Println(monster2)
}

func testMap() {
	/*
		2.将map序列化
	*/
	//var myMap map[string]interface{}
	myMap := make(map[string]interface{})
	myMap["name"] = "红孩儿"
	myMap["age"] = 100
	myMap["Birthday"] = "20000"
	myMap["Sal"] = 100.5
	data, err := json.Marshal(myMap)
	if err != nil {
		fmt.Println("序列化错误", err)
	}
	fmt.Println(string(data))

	//data是序列化的格式，接下来把data反序列化
	/*
		2.把map反序列化
		反序列化不需要make() 因为Unmarshal()已经封装好了
		可以查看go手册 Unmarshal()方法
	*/
	var myMap2 map[string]interface{}
	err2 := json.Unmarshal(data, &myMap2)
	if err2 != nil {
		fmt.Println("反序列化失败", err)
		return
	}
	fmt.Println("反序列化成功")
	fmt.Println(myMap2)
}

func testSlice() {
	/*
		3.将切片序列化
	*/
	var slice []map[string]interface{}
	map1 := make(map[string]interface{})
	map1["name"] = "map1"
	map1["age"] = 10
	map1["Birthday"] = "1002"
	map1["Sal"] = "map1~"
	map2 := make(map[string]interface{})
	map2["name"] = "map2"
	map2["age"] = 10
	map2["Birthday"] = [2]string{"1003", "qweqw"}
	map2["Sal"] = "map1~"
	slice = append(slice, map1)
	slice = append(slice, map2)
	data, err := json.Marshal(slice)
	if err != nil {
		fmt.Println("序列化错误", err)
	}
	fmt.Println(string(data))

	/*
		3.将切片反序列化
	*/
	var slice2 []map[string]interface{}
	err2 := json.Unmarshal(data, &slice2)
	if err2 != nil {
		fmt.Println("反序列化失败", err)
		return
	}
	fmt.Println("反序列化成功")
	fmt.Println(slice2)
}

func main() {

	testStruct()
	testMap()
	testSlice()
}

//cal_test.go包

package main
/*
规则1.单元测试代码的go文件必须以_test.go结尾，Go语言测试工具只会认符合这个规则的文件

规则2.单元测试的函数名必须以Test开头，是可导出公开的函数。备注：函数名最好是Test+要测试的方法函数名

规则3. 测试函数的签名必须接收一个指向testing.T类型的指针作为参数，并且该测试函数不能返回任何值
*/


import (
	"testing"
)

//编写测试用例，去测试addUpper()是否正确
//命令台指令补充
    //直接测试所有文件函数
    //	go test -v
	//测试单个函数
	//go test -v  -run  测试函数名字

	//测试单个文件
	//go test -v  xxx_test.go  xxx.go



func TestAddUpper(t *testing.T) {
	//调用
	res := addUpper(11)
	if res != 55 {
		t.Fatalf("结果错误，期望值%v, 实际%v", 55, res)
	}
	//如果正确输出日志
	t.Logf("执行正确!")
}

func TestGetSum(t *testing.T) {
	//调用
	res := getSum(11, 12)
	if res != 2223 {
		t.Fatalf("结果错误，期望值%v, 实际%v", 23, res)
	}
	//如果正确输出日志
	t.Logf("执行正确!")
	//测试单个函数
	//go test -v  -run  测试函数名字

	//测试单个文件
	//go test -v  xxx_test.go  xxx.go
}

//cal.go包

package main

func addUpper(n int) int {
	res := 0
	for i := 1; i <= n-1; i++ {
		res += i
	}
	return res
}

func getSum(n1 int, n2 int) int {
	return n1 + n2
}