Un article expliquant en détail le fonctionnement json de Golang

Cet article vous apporte des connaissances pertinentes sur Golang. Il vous présente principalement le fonctionnement json de Golang. Les amis intéressés peuvent jeter un œil ci-dessous. J'espère que cela sera utile à tout le monde.

l'opération json de Golang

JSON est un format d'échange de données léger. Facile à lire et à écrire. golang fournit le package encoding/json pour exploiter les données JSON. encoding/json 包来操作JSON数据。

1. 结构体与JSON互转

（1）使用 json.Marshal() 方法，把结构体转成 JSON字符串

import (
	"encoding/json"
	"fmt")type Student struct {
	Name string
	Age int
	Skill string}func main()  {
	stu := Student{"tom", 12, "football"}
	data, err := json.Marshal(&stu)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
		return
	}
	fmt.Println("序列化后: ", string(data))}

打印： 序列化后: {“Name”:“tom”,“Age”:12,“Skill”:“football”}

（2）JSON字符串 转 结构体，可以使用 json.Unmarshal()方法

func main()  {
	str := `{"Name":"tom","Age":12,"Skill":"football"}`
	var stu2 Student
	err := json.Unmarshal([]byte(str), &stu2)
	if err != nil {
		fmt.Printf("反序列化错误 err=%v\n", err)
		return
	}
	fmt.Printf("反序列化后: Student=%v, Name=%v\n", stu2, stu2.Name)}

打印: 反序列化后: Student={tom 12 football}, Name=tom

（3）如何实现结构体序列化后key的名称能自定义

对于自定义key的名称，可以给 struct变量指定一个tag标签

1. Convertir la structure en JSON

(1) Utilisez la méthode json.Marshal() pour convertir la structure en chaîne JSON

type Student struct {
	Name string   `json:"stu_name"`
	Age int       `json:"stu_age"`
	Skill string  // 也可以不指定 tag标签，默认就是 变量名称}func main()  {
	stu := Student{"tom", 12, "football"}
	data, err := json.Marshal(&stu)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
		return
	}
	fmt.Println("序列化后: ", string(data))}

Impression : Après sérialisation : {" Name": "tom", "Age": 12, "Skill": "football"}

(2) Pour convertir une chaîne JSON en structure, vous pouvez utiliser la méthode json.Unmarshal()

func main()  {
	// map 转 Json字符串
	m := make(map[string]interface{})
	m["name"] = "jetty"
	m["age"] = 16

	data, err := json.Marshal(&m)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
		return
	}
	fmt.Println("序列化后: ", string(data))    // 打印: 序列化后:  {"age":16,"name":"jetty"}

	// Json字符串 转 map
	str := `{"age":25,"name":"car"}`
	err = json.Unmarshal([]byte(str), &m)
	if err != nil {
		fmt.Printf("反序列化错误 err=%v\n", err)
		return
	}
	fmt.Printf("反序列化后: map=%v, name=%v\n", m, m["name"])
	// 打印: 反序列化后: map=map[age:25 name:car], name=car}

Print:

Après désérialisation : Student={tom 12 football}, Name=tom

(3) Comment se rendre compte que le nom de la clé peut être personnalisé après sérialisation de la structure

Pour personnaliser Pour définir le nom de la clé, vous pouvez spécifier un étiquette de balise pour la variable de structure

type User struct {
	Name string    `json:"u_name"`
	age int        `json:"u_age"`
	Skill string   // 也可以不指定 tag标签，默认就是 变量名称
	addr string}func main()  {
	user := User{"admin", 23, "football", "上海"}
	data, err := json.Marshal(&user)
	if err != nil {
		fmt.Printf("序列化错误 err=%v\n", err)
		return
	}
	fmt.Println("序列化后: ", string(data))  // 打印: 序列化后:  {"u_name":"admin","Skill":"football"}}

Après l'impression, vous pouvez voir que le nom de la clé a été remplacé par le nom de la étiquette de balise que nous avons spécifiée

Après la sérialisation : {" stu_name": "tom", "stu_age": 12, "Skill": "football"}

2 Carte et conversion mutuelle JSON

type User struct {
	Name string    `json:"u_name"`
	Password string `json:"password"`
	Email string `json:"email"`}func main()  {
	user := User{"admin", "pwd", "user@163.com"}
	person := Person{23, "上海"}
	// 忽略掉 Password 字段
	data, _ := json.Marshal(struct {
		*User
		Password string `json:"password,omitempty"`
	}{User: &user})
	fmt.Println("忽略字段: ", string(data))  // 打印: 忽略字段: {"u_name":"admin","email":"user@163.com"}}

3. les variables de la structure fonctionnent normalement sans ajouter de balises tag ? Convertir en données json

Si la première lettre de la variable est minuscule, elle est privée. Étant donné que les informations de réflexion ne peuvent pas être obtenues, elles ne peuvent pas être transférées.

Si la première lettre de la variable est en majuscule, elle est publique. Il peut être converti normalement, que des balises soient ajoutées ou non. Les variables avec des balises seront affichées en fonction du nom de la balise.

Exemple :

data, _ = json.Marshal(struct {
	*User
	Skill string `json:"skill"`  // 临时添加额外的 Skill字段}{
	User: &user,
	Skill: "football",})fmt.Println("添加额外字段: ", string(data))

En imprimant, nous avons constaté que les variables minuscules, telles que l'âge et l'adresse, n'étaient pas converties en données json.

Résumé :

Si la première lettre est minuscule, elle ne peut pas être convertie en données json, qu'elle soit balisée ou non, tandis que si elle est majuscule et balisée, elle peut être aliasée sans balises, les champs en json. seront les mêmes que les noms d'origine des variables de structure

4. Quelques conseils pour les opérations JSON

(1) Ignorez les champs spécifiés par la structure

type User struct {
	Name string    `json:"u_name"`
	Password string `json:"password"`
	Email string `json:"email"`}type Person struct {
	Age int
	Addr string `json:"addr"`}func main()  {
    // 初始化两个 struct
	user := User{"admin", "pwd", "user@163.com"}
	person := Person{23, "上海"}
	
	data, _ := json.Marshal(struct {
		*User		*Person	}{
		User: &user,
		Person: &person,
	})
	
	fmt.Println("合并两个struct: ", string(data))}

Ignorez les champs : {"u_name": "admin" ,"email":"user@163.com"}}

(2) Ajouter des champs supplémentaires

emp := struct {                    // 创建匿名 struct
	Num int `json:"num,string"`}{15,}data, _ := json.Marshal(&emp)fmt.Println("数字转成字符串: ", string(data))       // 数字转成字符串: {"num":"15"}str := `{"Num":"25"}`_ = json.Unmarshal([]byte(str), &emp)fmt.Printf("字符串转成数字: Emp.Num=%v\n", emp.Num) // 字符串转成数字: Emp.Num=25

Ajouter des champs supplémentaires : {"u_name":"admin","password":"pwd","email ":"user@163.com","skill" :"football"}

(3) Fusionner deux structures

str = ` {"u_name":"system","password":"abc","email":"user2@163.com","Age":23,"addr":"杭州"}`var user2 Uservar person2 Person_ := json.Unmarshal([]byte(str), &struct {
	*User	*Person}{
	User: &user2,
	Person: &person2,})fmt.Printf("分成两个struct: User=%v, Person=%v\n", user2, person2)

Fusionner deux structures : {"u_name":"admin","password":"pwd ","email":"user@163. com", "Age": 23, "addr": "Shanghai"}🎜🎜🎜 (4) La chaîne est passée au type int🎜rrreee🎜🎜🎜 (5 ) Un json est divisé en deux struct🎜rrreee🎜 struct : User={system abc user2@163.com}, Person={23 Hangzhou}🎜🎜🎜🎜🎜🎜🎜🎜🎜Apprentissage recommandé : "🎜go video tutoriel🎜" 🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!