Ein Artikel, der die JSON-Operation von Golang im Detail erklärt

Dieser Artikel vermittelt Ihnen relevantes Wissen über Golang. Er stellt Ihnen hauptsächlich die JSON-Operationen von Golang vor. Ich hoffe, dass er für alle hilfreich ist.

Golangs JSON-Operation

JSON ist ein leichtes Datenaustauschformat. Leicht zu lesen und zu schreiben. Golang stellt das Paket encoding/json zum Bearbeiten von JSON-Daten bereit. 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. Struktur in JSON konvertieren

(1) Verwenden Sie die Methode json.Marshal(), um die Struktur in einen JSON-String zu konvertieren

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))}

Drucken: Nach der Serialisierung: {" Name“: „tom“, „Alter“: 12, „Skill“: „football“}

(2) Um einen JSON-String in eine Struktur umzuwandeln, können Sie die Methode json.Unmarshal() verwenden

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}

Drucken:

Nach der Deserialisierung: Student={tom 12 football}, Name=tom

(3) Wie man erkennt, dass der Name des Schlüssels nach der Serialisierung der Struktur angepasst werden kann

Für benutzerdefinierte Um den Namen des Schlüssels zu definieren, können Sie ein tag label für die Strukturvariable angeben

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"}}

Nach dem Drucken können Sie sehen, dass sich der Name des Schlüssels in den Namen des geändert hat Tag-Label, das wir angegeben haben

Nach der Serialisierung: {" stu_name": "tom", "stu_age":12, "Skill": "football"}

2. gegenseitige Konvertierung von Karte und JSON

3 Funktionieren die Variablen der Struktur normal, ohne Tag-Tags hinzuzufügen? In JSON-Daten konvertieren

Wenn der erste Buchstabe der Variable ein Kleinbuchstabe ist, ist er privat. Da die Reflexionsinformationen nicht erhalten werden können, können sie nicht übertragen werden.

Wenn der erste Buchstabe der Variable großgeschrieben wird, ist sie öffentlich. Es kann normal konvertiert werden, unabhängig davon, ob Tags hinzugefügt wurden oder nicht. Variablen mit Tags werden entsprechend dem Namen des Tags angezeigt.

Beispiel:

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"}}

Beim Drucken haben wir festgestellt, dass Kleinbuchstabenvariablen wie Alter und Adresse nicht in JSON-Daten umgewandelt wurden.

Zusammenfassung:

Wenn der erste Buchstabe ein Kleinbuchstabe ist, kann er nicht in JSON-Daten umgewandelt werden, unabhängig davon, ob er mit Tags versehen ist oder nicht. Wenn er jedoch in Großbuchstaben geschrieben und mit Tags versehen ist, können die Felder in JSON mit einem Alias ​​versehen werden wird mit den ursprünglichen Namen der Strukturvariablen übereinstimmen

4 Einige Tipps für JSON-Operationen

(1) Ignorieren Sie die von der Struktur angegebenen Felder

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

Ignorieren Sie die Felder: {"u_name": "admin" ,"email": "user@163.com"}}

(2) Zusätzliche Felder hinzufügen

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))}

(3) Zwei Strukturen zusammenführen

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

Zwei Strukturen zusammenführen: {"u_name": "admin", "password": "pwd ","email="user@163. com", "Age": 23, "addr": "Shanghai"}

🎜🎜 (4) Der String wird an den int-Typ übergeben🎜

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)

🎜🎜🎜 (5 ) Ein JSON ist in zwei Strukturen unterteilt. 🎜🎜

Das obige ist der detaillierte Inhalt vonEin Artikel, der die JSON-Operation von Golang im Detail erklärt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!