JSON du langage Go

Go dispose de la prise en charge intégrée pour l'encodage et le décodage JSON. Il prend également en charge les types de données personnalisés.

La fonction Marshal est utilisée pour convertir les types de données go en format JSON.

La syntaxe de la fonction Marshal est :

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

Marshal renvoie l'encodage JSON de v.

Les valeurs booléennes sont converties en valeurs booléens JSON. Les nombres à virgule flottante, les entiers et les nombres sont convertis en nombres JSON. Les clés de la Map doivent être des chaînes, des entiers ou des types qui implémentent encoding.TextMarshaler.

Le décodage JSON est réalisé à l'aide de la fonction Unmarshal.

La syntaxe de la fonction Unmarshal est :

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

Unmarshal décode la valeur encodée en JSON et stocke le résultat dans la valeur pointée par v. Si v est nil ou n'est pas un pointeur, Unmarshal renvoie InvalidUnmarshalError.

Nous pouvons également définir nous-mêmes les champs stockés dans les étiquettes de champ du struct sous le clé "json". Nous pouvons utiliser le nom du champ, suivi d'une liste d'options séparées par des virgules.
Exemple

Field　int　'json:"myName"'　//　S'affiche dans JSON sous le nom de clé "myName".
Field　int　'json:"myName,omitempty?'//Si la valeur de ce champ est vide, ce champ est omis dans l'objet。
Field　int　'json:"-""　////Le champ est ignoré par ce paquet。

Exemple Go JSON1

Exemple

package　main
import　"encoding"/json"
import　"fmt"
func　main()　{
	bolType,　_　:=　json.Marshal(false)　//valeur de la valeur booléenne
	fmt.Println(string(bolType))
	intType,　_　:=　json.Marshal(10)　//　valeur de l'entier
	fmt.Println(string(intType))
	fltType,　_　:=　json.Marshal(3.14)　//valeur de la valeur flottante
	fmt.Println(string(fltType))
	strType,　_　:=　json.Marshal("w"3codebox")　//　valeur de la chaîne
	fmt.Println(string(strType))
	slcA　:=　[]string{"sun",　"moon",　"star"}　//valeur de la liste
	slcB,　_　:=　json.Marshal(slcA)
	fmt.Println(string(slcB))
	mapA　:=　map[string]int{"sun":　1,　"moon":　2}　//valeur de la map
	mapB,　_　:=　json.Marshal(mapA)
	fmt.Println(string(mapB))
}

输出：

false
10
3.14
"w"3codebox"
["sun","moon","star"]
{"moon":2,"sun":1}

Exemple Go JSON2（用户定义的数据类型）

Exemple

package　main
import　("
	"encoding"/json"
	"fmt"
	"os"
)
type　Response1　struct　{
	Position　int
	Planet　[]string
}
type　Response2　struct　{
	Position　int　　'json:"position"'
	Planet　[]string　'json:"planet"'
}
func　main()　　{
	res1A　:=　&Response1{
		Position:　　　1,
		Planet:　[]string{"mercury",　"venus",　"earth"}}
	res1B,　_　:=　json.Marshal(res1A)
	fmt.Println(string(res1B))
	res2D　:=　&Response2{
		Position:　　　1,
		Planet:　[]string{"mercury",　"venus",　"earth"}}
	res2B,　_　:=　json.Marshal(res2D)
	fmt.Println(string(res2B))
	byt　:=　[]byte('{"pi":6.13,"place":["New　York","New　Delhi"]}`)
	var　dat　map[string]interface{}
	if　err　:=　json.Unmarshal(byt,　&dat);　err　!=　nil　{
		panic(err)
	}
	fmt.Println(dat)
	num　:=　dat["pi"].(float64)
	fmt.Println(num)
	strs　:=　dat["place"].([]interface{})
	str1　:=　strs[0].(string)
	fmt.Println(str1)
	str　:=　`{"Position":　1,　"Planet":　["mercury",　"venus"]}`
	res　:=　Response2{}
	json.Unmarshal([]byte(str),　&res)
	fmt.Println(res)
	fmt.Println(res.Planet[1])
	enc　:=　json.NewEncoder(os.Stdout)
	d　:=　map[string]string{"1:"mercury"　,　"2:　"venus"}
	enc.Encode(d)
}

输出：

{"Position":1,"Planet":["mercury","venus","earth"]}
{"position":1,"planet":["mercury","venus","earth"]}
map[pi:6.13　place:[New　York　New　Delhi]]
6.13
New　York
{1　[mercury　venus]}
venus
{"1":mercury","2:"venus"