codificación json de la biblioteca estándar golang

Este paquete puede realizar la codificación y decodificación de json, que consiste en convertir la cadena json a structjson struct.

Las dos funciones básicas

Función de codificación Marshal

func Marshal(v interface{}) ([]byte, error)

Codifique la estructura o el mapa en json, que puede recibir cualquier tipo

Convertir estructura a json

package main  
  
import (  
   "encoding/json"  
   "fmt")  
  
type Person struct {  
   Name  string  
   Age   int  
   Email string  
}  
  
func Marsha() {  
   p := Person{  
      Name:  "tom",  
      Age:   20,  
      Email: "[email protected]",  
   }  
   b, _ := json.Marshal(p)  
   fmt.Printf("b: %v\n", string(b))  
}  
func main() {  
   Marsha()  
}

mapa convertido a json

package main  
  
import (  
   "encoding/json"  
   "fmt")  
  
type Person struct {  
   Name  string  
   Age   int  
   Email string  
}  
  
func Marsha() {  
   p := make(map[string]interface{}, 20)  
   p["名称"] = "张三"  
   p["性别"] = "男"  
   p["年龄"] = "18"  
   b, _ := json.Marshal(p)  
   fmt.Printf("b: %v\n", string(b))  
}  
func main() {  
   Marsha()  
}

Función de decodificación Unmarshal

func Unmarshal(data []byte, v interface{}) error

Transcodificar json en estructura de estructura o mapa

El punto clave de esta función es el tipo de datos de v, pero se recomienda usar la estructura como el tipo de v. Después de todo, puede usar la etiqueta etiqueta para analizar los datos con mayor precisión. Atención especial: el segundo parámetro debe ser pasado en la dirección, de lo contrario la modificación no tendrá éxito

json para mapear

package main  
  
import (  
   "encoding/json"  
   "fmt")  
  
type Person struct {  
   Name  string  
   Age   int  
   Email string  
}  
  
func Marsha() []byte {  
   p := make(map[string]interface{}, 20)  
   p["名称"] = "张三"  
   p["性别"] = "男"  
   p["年龄"] = "18"  
   b, _ := json.Marshal(p)  
   return b  
}  
func Unmarshal(b []byte) {  
   var m map[string]interface{}  
   json.Unmarshal(b, &m)  
   fmt.Printf("%v\n", m)  
}  
func main() {  
   Unmarshal(Marsha())  
}

Convertir json a estructura

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name   string
	Age    int
	Gender string
}

func Marsha() []byte {
	p := make(map[string]interface{}, 20)
	p["name"] = "张三"
	p["gender"] = "男"
	p["age"] = "18"
	b, _ := json.Marshal(p)
	return b
}
func Unmarshal(b []byte) {
	var m Person
	json.Unmarshal(b, &m)
	fmt.Printf("%v\n", m)
}
func main() {
	Unmarshal(Marsha())
}

analizar tipos anidados

package main

import (
	"encoding/json"
	"fmt"
)

type Parents []string
type Person struct {
	Name  string
	Age   int
	Email string
	Parents
}

// 解析嵌套类型
func Unmarshal() {
	b := []byte(`{"Name":"tom","Age":20,"Email":"[email protected]", "Parents":["tom", "kite"]}`)
	var f Person
	json.Unmarshal(b, &f)
	fmt.Printf("f: %v\n", f)
}
func main() {
	Unmarshal()
}

ignorar campo

Si desea codificar/decodificar en json (serializar o deserializar) para ignorar un campo en la estructura, puede agregarlo a la etiqueta de la siguiente manera -.
Si desea ignorar un campo en la estructura durante la serialización/deserialización json, puede agregarlo a la etiqueta de la siguiente manera -.

Por supuesto, si pone el nombre de la variable en minúsculas, también puede lograr el efecto de ignorarlo.§( ￣▽￣ )§

// 使用json tag指定json序列化与反序列化时的行为
type Person struct {
	Name   string `json:"name"` // 指定json序列化/反序列化时使用小写name
	Age    int64
	Weight float64 `json:"-"` // 指定json序列化/反序列化时忽略此字段
}

Ignorar campos vacíos

Cuando los campos en la estructura no tienen valor, json.Marshal()estos campos no se ignorarán durante la serialización, pero el valor de tipo cero del campo de salida predeterminado (por ejemplo, el valor de inttipo floatcero es 0, stringel valor de tipo cero es ""y el tipo de objeto el valor cero es nulo). Si desea ignorar estos campos sin valores durante la serialización, puede agregar omitemptyetiquetas a los campos correspondientes.

Por ejemplo:

type User struct {
	Name  string   `json:"name"`
	Email string   `json:"email"`
	Hobby []string `json:"hobby"`
}

func omitemptyDemo() {
	u1 := User{
		Name: "七米",
	}
	// struct -> json string
	b, err := json.Marshal(u1)
	if err != nil {
		fmt.Printf("json.Marshal failed, err:%v\n", err)
		return
	}
	fmt.Printf("str:%s\n", b)
}

Resultado de salida:

str:{"name":"七米","email":"","hobby":null}

Si desea eliminar campos nulos en el resultado final de la serialización, puede definir una estructura como esta:

// 在tag中添加omitempty忽略空值
// 注意这里 hobby,omitempty 合起来是json tag值，中间用英文逗号分隔
type User struct {
	Name  string   `json:"name"`
	Email string   `json:"email,omitempty"`
	Hobby []string `json:"hobby,omitempty"`
}

En este punto, ejecute lo anterior nuevamente omitemptyDemo, el resultado de salida es el siguiente:

str:{"name":"七米"} // 序列化结果中没有email和hobby字段

Ignorar campos vacíos de estructuras anidadas

Veamos primero varios ejemplos de anidamiento de estructuras:

type User struct {
	Name  string   `json:"name"`
	Email string   `json:"email,omitempty"`
	Hobby []string `json:"hobby,omitempty"`
	Profile
}

type Profile struct {
	Website string `json:"site"`
	Slogan  string `json:"slogan"`
}

func nestedStructDemo() {
	u1 := User{
		Name:  "七米",
		Hobby: []string{"足球", "双色球"},
	}
	b, err := json.Marshal(u1)
	if err != nil {
		fmt.Printf("json.Marshal failed, err:%v\n", err)
		return
	}
	fmt.Printf("str:%s\n", b)
}

ProfileLa cadena json serializada en el anidamiento anónimo es de una sola capa:

str:{"name":"七米","hobby":["足球","双色球"],"site":"","slogan":""}

Si desea convertirlo en una cadena json anidada, debe cambiarlo a un nido con nombre o definir una etiqueta de campo:

type User struct {
	Name    string   `json:"name"`
	Email   string   `json:"email,omitempty"`
	Hobby   []string `json:"hobby,omitempty"`
	Profile `json:"profile"`
}
// str:{"name":"七米","hobby":["足球","双色球"],"profile":{"site":"","slogan":""}}

Para ignorar el campo cuando la estructura anidada está vacía, agregar omitemptyno es suficiente:

type User struct {
	Name     string   `json:"name"`
	Email    string   `json:"email,omitempty"`
	Hobby    []string `json:"hobby,omitempty"`
	Profile `json:"profile,omitempty"`
}
// str:{"name":"七米","hobby":["足球","双色球"],"profile":{"site":"","slogan":""}}

También necesita usar punteros de estructura anidados:

type User struct {
	Name     string   `json:"name"`
	Email    string   `json:"email,omitempty"`
	Hobby    []string `json:"hobby,omitempty"`
	*Profile `json:"profile,omitempty"`
}
// str:{"name":"七米","hobby":["足球","双色球"]}

No modifique la estructura original e ignore los campos de valor nulo

Necesitamos la serialización json User, pero no queremos serializar la contraseña , y no queremos modificar Userla estructura.En este momento, podemos crear otra estructura PublicUserfuente anónima anidada User, especificar Passwordel campo como un tipo de puntero de estructura anónima, y agregue omitemptyuna etiqueta El código de muestra es el siguiente:

type User struct {
	Name     string `json:"name"`
	Password string `json:"password"`
}

type PublicUser struct {
	*User             // 匿名嵌套
	Password *struct{} `json:"password,omitempty"`
}

func omitPasswordDemo() {
	u1 := User{
		Name:     "七米",
		Password: "123456",
	}
	b, err := json.Marshal(PublicUser{User: &u1})
	if err != nil {
		fmt.Printf("json.Marshal u1 failed, err:%v\n", err)
		return
	}
	fmt.Printf("str:%s\n", b)  // str:{"name":"七米"}
}