json序列化

sonic实现

package main

import (
	"fmt"

	"github.com/bytedance/sonic"
)

// 定义一个测试结构体
type User struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
	Addr string `json:"addr,omitempty"`
}

func main() {
	// 创建一个User实例
	user := User{
		Name: "张三",
		Age:  25,
		// 不设置Addr，会被omitempty忽略
	}

	// 序列化：将结构体转换为JSON字符串
	jsonStr, err := sonic.Marshal(user)
	if err != nil {
		fmt.Printf("序列化失败: %v\n", err)
		return
	}
	fmt.Printf("序列化结果: %s\n", jsonStr)

	// 反序列化：将JSON字符串转换为结构体
	var newUser User
	err = sonic.Unmarshal(jsonStr, &newUser)
	if err != nil {
		fmt.Printf("反序列化失败: %v\n", err)
		return
	}
	fmt.Printf("反序列化结果: Name=%s, Age=%d\n", newUser.Name, newUser.Age)

	/**
	序列化结果: {"name":"张三","age":25}
	反序列化结果: Name=张三, Age=25
	*/
}

原生实现

格式化

注意，结构体的字段必须是大写的，否者json输出不认，艹，好难受啊

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	// 结构体变量一定要大写，否则获取不到
	Company  string
	Subjects []string
	IsOK     bool
	Score    float64
}

/*
*
结构体/map-=json.Marshal=>[]byte-=string()=>string
*/
func main() {
	s := IT{"itcast", []string{"Go", "C++", "Java"}, false, 6.4}
	//buf, err := json.Marshal(s);
	buf, err := json.MarshalIndent(s, "", "    ") // indent最好4个空格，累容
	// buf是byte类型
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println("buf =", string(buf))
	/**
	buf = {
	    "Company": "itcast",
	    "Subjects": [
	        "Go",
	        "C++",
	        "Java"
	    ],
	    "IsOK": false,
	    "Score": 6.4
	}
	*/

	// 通过map生成json
	map1 := make(map[string]interface{}, 4)
	map1["Company"] = "q"
	map1["Subjects"] = 13
	map1["IsOK"] = IT{"itcast", []string{"Go", "C++", "Java"}, false, 6.4}
	map1["a"] = [...]int{1, 3, 6, 9}
	buf, err = json.Marshal(map1)
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println("buf =", string(buf)) //buf = {"Company":"q","IsOK":{"Company":"itcast","Subjects":["Go","C++","Java"],"IsOK":false,"Score":6.4},"Subjects":13,"a":[1,3,6,9]}

}

struct tag

就是对字段特殊处理一下

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	// 结构体变量一定要大写，否则获取不到
	Company  string   `json:"-"`        // 此字段不会输出到屏幕
	Subjects []string `json:"subjects"` // 二次编码
	IsOK     bool     `json:",string"`  //
	Score    float64
}

func main() {
	s := IT{"itcast", []string{"Go", "C++", "Java"}, false, 6.4}
	//buf, err := json.Marshal(s);
	buf, err := json.MarshalIndent(s, "", "    ") // indent最好4个空格，累容
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println("buf =", string(buf))

	/**
	buf = {
	    "subjects": [
	        "Go",
	        "C++",
	        "Java"
	    ],
	    "IsOK": "false",
	    "Score": 6.4
	}
	*/

	// 创建一个保存键值对的映射
	t1 := make(map[string]interface{})
	t1["company"] = "itcast"
	t1["subjects "] = []string{"Go", "C++", "Python", "Test"}
	t1["isok"] = true
	t1["price"] = 666.666

	b, err := json.Marshal(t1)
	//json.MarshalIndent(t1, "", "")
	if err != nil {
		fmt.Println("json err:", err)
	}
	fmt.Println(string(b))
	//输出结果：{"company":"itcast","isok":true,"price":666.666,"subjects ":["Go","C++","Python","Test"]}
}

json字符串转结构体

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	// 结构体变量一定要大写，否则获取不到
	Company  string
	Subjects []string
	IsOK     bool
	Score    float64
}

func main() {
	s := "{\"Company\": \"kakaluote\",\"Subjects\": [\"Go\",\"C++\",\"Java\"],\"IsOK\": false,\"Score\": 6.4}"

	// 解析到结构体
	var tmp IT
	fmt.Println("s =", s)
	err := json.Unmarshal([]byte(s), &tmp) // 只能传对象地址，指针还不行我去
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println(tmp)

	// 解析到map
	map1 := make(map[string]interface{}, 4)
	err = json.Unmarshal([]byte(s), &map1)
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println(map1)
	fmt.Println("str =", map1["Company"]) // 视频上说这里会报错，需要使用类型断言

	for key, value := range map1 {
		fmt.Printf("key = %v, value = %v...", key, value)
		switch value.(type) { // 类型断言的标准写法
		case string:
			fmt.Printf("the type of map[%s] is string", key)
			break
		case int:
			fmt.Printf("the type of map[%s] is int", key)
			break
		case []string: // 匹配不到
			fmt.Printf("the type of map[%s] is []string", key)
			break
		case []interface{}: // 这才能匹配到
			fmt.Printf("the type of map[%s] is []interface", key)
			break
		case bool:
			fmt.Printf("the type of map[%s] is bool", key)
			break
		case float64:
			fmt.Printf("the type of map[%s] is float64", key)
			break
		}
		fmt.Printf("\n")
	}

	/***
	s = {"Company": "kakaluote","Subjects": ["Go","C++","Java"],"IsOK": false,"Score": 6.4}
	{kakaluote [Go C++ Java] false 6.4}
	map[Company:kakaluote IsOK:false Score:6.4 Subjects:[Go C++ Java]]
	str = kakaluote
	key = Company, value = kakaluote...the type of map[Company] is string
	key = Subjects, value = [Go C++ Java]...the type of map[Subjects] is []interface
	key = IsOK, value = false...the type of map[IsOK] is bool
	key = Score, value = 6.4...the type of map[Score] is float64
	*/
}