JSON del linguaggio Go

Go ha supporto integrato per la codifica e decodifica JSON. Supporta anche i tipi di dati personalizzati.

La funzione Marshal viene utilizzata per convertire i tipi di dati go in formato JSON.

La sintassi della funzione Marshal è:

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

Marshal restituisce la codifica JSON del valore v.

Valori booleani vengono convertiti in valori booleani JSON. Numeri a virgola mobile, interi e numerici vengono convertiti in numeri JSON. I tipi di chiave della mappa devono essere stringhe, tipi integer o implementare encoding.TextMarshaler.

La decodifica JSON è completata utilizzando la funzione Unmarshal.

La sintassi della funzione Unmarshal è:

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

Unmarshal decodifica i valori codificati in JSON e li memorizza nel valore puntato da v. Se v è nil o non è un puntatore, Unmarshal restituisce InvalidUnmarshalError.

Possiamo anche definire campi personalizzati memorizzati nelle etichette del campo struct sotto la chiave 'json'. Possiamo usare il nome del campo, seguiti da una lista di opzioni separate da virgola.
Esempio

Field int 'json:"myName"' // Viene visualizzato come chiave 'myName' nel JSON.
Field int 'json:"myName,omitempty?'//Se il valore del campo è vuoto, il campo viene omesso dall'oggetto.
Field　int　'json:"-"'　////Il campo viene ignorato da questo pacchetto。

Esempio JSON Go 1

Esempio

package　main
import　"encoding/json"
import　"fmt"
func　main()　{
	bolType,　_　:=　json.Marshal(false)　//valore booleano
	fmt.Println(string(bolType))
	intType,　_　:=　json.Marshal(10)　//valore intero
	fmt.Println(string(intType))
	fltType,　_　:=　json.Marshal(3.14)　//valore floating point
	fmt.Println(string(fltType))
	strType,　_　:=　json.Marshal("w3codebox")　//valore stringa
	fmt.Println(string(strType))
	slcA　:=　[]string{"sun",　"moon",　"star"}　//valore elenco
	slcB,　_　:=　json.Marshal(slcA)
	fmt.Println(string(slcB))
	mapA　:=　map[string]int{"sun":　1,　"moon":　2}　//valore mappa
	mapB,　_　:=　json.Marshal(mapA)
	fmt.Println(string(mapB))
}

Output:

false
10
3.14
"w3codebox"
["sun","moon","star"]
{"moon":2,"sun":1}

Esempio JSON Go 2 (tipi di dati definiti dall'utente)

Esempio

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

Output:

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