JSON (JavaScript Object Notation) è un formato di dati molto versatile e molto diffuso. Viene spesso utilizzato per la comunicazione tra app Web e anche come modo conveniente per archiviare grandi quantità di dati applicativi strutturati.

JSON è così utile che quasi tutti i linguaggi di programmazione moderni forniscono supporto integrato per lavorare con esso, incluso Go.

Lavorare con JSON in Go

Puoi dividere la maggior parte del lavoro che farai con JSON in due categorie generali: marshalling e unmarshaling. Wikipedia definisce il marshalling come:

In informatica, il marshalling è il processo di trasformazione della rappresentazione della memoria di un oggetto in un formato di dati adatto per l'archiviazione o la trasmissione. Viene tipicamente utilizzato quando i dati devono essere spostati tra diverse parti di un programma per computer o da un programma all'altro.

In termini più semplici, il marshalling è il processo di conversione dei dati archiviati in una variabile in un formato più facile da passare a un altro programma. L'unmarshaling è il processo inverso: implica prendere i dati formattati per il trasporto e convertirli in un formato più facile da usare per il tuo programma.

instagram viewer

Utilizzando Go, puoi eseguire il marshalling di strutture di dati native in JSON. E puoi eseguire l'azione inversa, separando i dati JSON nelle variabili Go.

Marshaling a JSON in Go

Go fornisce il encoding/pacchetto json per semplificare il lavoro con JSON. Questo pacchetto contiene diverse funzioni, ma quella che utilizzerai per il marshalling è la Maresciallo funzione. Maresciallo ha la seguente firma di funzione:

func Maresciallo (v interfaccia{}) ([]byte, errore)

Ciò significa che Maresciallo accetta un parametro di qualsiasi tipo di dati e restituisce due valori: una fetta di byte e un errore. In altre parole, chiami Maresciallo con un valore Go e lo converte in JSON e restituisce l'equivalente JSON. Se incontra un errore durante il processo di conversione, restituirà l'errore e una sezione vuota.

Ecco un esempio di codice che utilizza Maresciallo per convertire una mappa in JSON. Per eseguire questo esempio, è sufficiente creare un file Go in il tuo editor di codice preferito, o usa il Vai al parco giochi:

pacchetto principale
importare (
"codifica/json"
"fmt"
)


funz principale(){
 val := mappa[stringa]int{
"John": 25,
"Maria": 19,
"Adamo": 5,
 }
res, _ := json. Maresciallo (val)
fmt.Stampaln(corda(ris))
}

Se esegui quel codice, produrrà quanto segue:

Come accennato in precedenza, puoi eseguire il marshalling di qualsiasi tipo di dati Go su JSON, anche se nella vita reale di solito esegui il marshalling delle strutture. Per questo motivo, Go fornisce una funzionalità chiamata tag struct per consentirti di dare Maresciallo istruzioni aggiuntive per convertire le tue strutture.

Un tag struct è una stringa che includi nella tua dichiarazione struct accanto al tipo di dati di un campo. I tag struct ti consentono di regolare il modo Maresciallo tratta il campo a cui appartiene il tag. Puoi utilizzare i tag struct per rinominare un campo nell'output JSON o persino ometterlo completamente. I tag struct (quello Maresciallo riconosce) iniziano con la sottostringa "json:".

Ad esempio, supponi di avere una struttura Auto che rappresenta alcune informazioni su un'auto. Ecco il codice per creare un file Auto e esegui il marshalling su JSON:

pacchetto principale
importare (
"codifica/json"
"fmt"
)
funz principale(){
tipo Car struct {
 Stringa di marca
 Stringa modello
 Prezzo int
 }
 val := Auto{Marca: "Mercedes", Modello: "Benz", Prezzo: 50000}
 res, _ := json. Maresciallo (val)
fmt.Stampaln(corda(ris))
}

Questo codice produce l'output:

IL Marca, Modello, E Prezzo campi di Auto è necessario iniziare con lettere maiuscole o Maresciallo non sarà in grado di convertirli. Ciò comporta che anche i campi di output JSON inizino con lettere maiuscole. Ma cosa succede se si desidera che i nomi inizino con lettere minuscole nel JSON o se si desidera rinominare completamente un campo? È qui che entrano in gioco i tag struct. Ecco un esempio:

pacchetto principale
importare (
"codifica/json"
"fmt"
)
funz principale(){
tipo Car struct {
 ID int `json:"-"`
 Stringa di marca `json:"tipo"`
 Stringa del modello `json:"modello"`
 Prezzo int `json:"prezzo"`
 }
 val := Auto{ID: 0, Marca: "Mercedes", Modello: "Benz", Prezzo: 50000}
 res, _ := json. Maresciallo (val)
fmt.Stampaln(corda(ris))
}

Questo codice introduce un nuovo campo ID che Maresciallo omette dall'output JSON tramite un tag struct. Il codice utilizza anche i tag struct per rinominare gli altri campi struct. Ecco l'output del programma:

Come puoi vedere, la parte del tag struct che segue "json:" diventa il nome del campo nell'output di Marshal. C'è un'eccezione: se è la stringa "-", Marshal omette quel campo dall'output. Puoi leggere di più sui tag Marshal e struct nel file Vai alla documentazione.

Annullamento del marshalling da JSON in Go

Il pacchetto encoding/json fornisce anche una funzione di unmarshaling, chiamata Non maresciallo. Ha la seguente firma di funzione:

func Unmarshal (data []byte, v interfaccia{}) errore

A differenza di Maresciallo, Non maresciallo non restituisce un valore. Invece, accetta JSON come una porzione di byte nel primo argomento e quindi archivia i dati convertiti nell'oggetto indicato dal suo secondo argomento. Non maresciallo funziona anche con i tag struct, ma qui lo dicono i tag Non maresciallo quali campi JSON corrispondono a quali campi struct.

Durante l'unmarshalling in un programma, potresti recuperare i dati da un'API, ma qui utilizzerai dati fittizi. Ecco come si usa Non maresciallo:

pacchetto principale
importare (
"codifica/json"
"fmt"
)


funz principale(){
tipo Car struct {
 ID int `json:"-"`
 Stringa di marca `json:"tipo"`
 Stringa del modello `json:"modello"`
 Prezzo int `json:"prezzo"`
 }


jsonInput := `{
"tipo": "Toyota",
"modello": "Camry",
"prezzo": 2000
 }`


var jsonOutput Auto
 err := json. Unmarshal([]byte(jsonInput), &jsonOutput)


se err != nil {
 fmt. Stampaln("Errore di decodifica JSON!")
ritorno
 }
fmt.Stampaln(jsonOutput)
}

Questo codice utilizza lo stesso tipo Car dell'esempio precedente ed esegue l'unmarshalling di un oggetto JSON in una struttura di tipo Car, quindi stampa i dati nella struttura. Quando viene eseguito, il programma produce questo output:

Ciò dimostra che i dati JSON fittizi sono stati sottoposti a un marshalling riuscito nel file jsonOutput struct.

Go semplifica il lavoro con JSON

Con il pacchetto encoding/json, lavorare con JSON in Go è semplice come due chiamate di funzione: Marsha e Unmarshal. Go ti consente anche di personalizzare il processo di marshalling/unmarshaling di JSON con i tag struct.

La conversione dei dati in JSON è un ottimo modo per condividerli con un altro programma o processo. Il formato è così universale che JSON è il più portatile possibile.