JSON (JavaScript Object Notation) er et svært allsidig og svært populært dataformat. Den brukes ofte til kommunikasjon mellom nettapper og også som en praktisk måte å lagre store mengder strukturerte applikasjonsdata på.

JSON er så nyttig at nesten alle moderne programmeringsspråk gir innebygd støtte for å jobbe med det, inkludert Go.

Arbeide med JSON i Go

Du kan dele det meste av arbeidet du skal gjøre med JSON i to generelle kategorier: marshaling og unmarshaling. Wikipedia definerer marshaling som:

I informatikk er marshaling prosessen med å transformere minnerepresentasjonen til et objekt til et dataformat som er egnet for lagring eller overføring. Det brukes vanligvis når data må flyttes mellom ulike deler av et dataprogram eller fra ett program til et annet.

I enklere termer er marshaling prosessen med å konvertere data som er lagret i en variabel til en form som er lettere å overføre til et annet program. Unmarshaling er den omvendte prosessen: det innebærer å ta data formatert for transport og konvertere dem til et skjema som er enklere for programmet å bruke.

instagram viewer

Ved å bruke Go kan du samle innfødte datastrukturer inn i JSON. Og du kan utføre den omvendte handlingen ved å dele JSON-data inn i Go-variabler.

Marshaling til JSON i Go

Go gir encoding/json-pakken for å gjøre det enkelt for deg å jobbe med JSON. Denne pakken inneholder flere funksjoner, men den du skal bruke til marshaling er Marskalk funksjon. Marskalk har følgende funksjonssignatur:

func marskalk (v grensesnitt{}) ([]byte, feil)

Dette betyr at Marskalk godtar en parameter av en hvilken som helst datatype, og returnerer to verdier: en bit av byte og en feil. Du ringer med andre ord Marskalk med en Go-verdi, og den konverterer den til JSON og returnerer JSON-ekvivalenten. Hvis den støter på en feil under konverteringsprosessen, returnerer den feilen og en tom skive.

Her er et kodeeksempel som bruker Marskalk for å konvertere et kart til JSON. For å kjøre dette eksemplet, er alt du trenger å lage en Go-fil i din favorittkoderedigerer, eller bruk Gå på lekeplassen:

pakke hoved-
import (
"koding/json"
"fmt"
)


func hoved-(){
 val := kart[streng]int{
"john": 25,
"mary": 19,
"adam": 5,
 }
res, _ := json. Marshal (val)
fmt.Skriv ut(streng(res))
}

Hvis du kjører den koden, vil den sende ut følgende:

Som nevnt før, kan du samle alle typer Go-data til JSON, men i det virkelige liv vil du vanligvis samle strukturer. På grunn av dette tilbyr Go en funksjon kalt struct-tags for å la deg gi Marskalk ekstra instruksjoner for å konvertere strukturene dine.

En struct-tag er en streng du inkluderer i struct-deklarasjonen ved siden av datatypen til et felt. Strukturtagger lar deg justere veien Marskalk behandler feltet taggen tilhører. Du kan bruke struct-tagger til å gi nytt navn til et felt i JSON-utdata, eller til og med utelate det helt. Struktur-tagger (det Marskalk gjenkjenner) start med delstrengen "json:".

Som et eksempel, si at du har en struktur Bil som representerer noe informasjon om en bil. Her er koden for å lage en Bil og marshaler det til JSON:

pakke hoved-
import (
"koding/json"
"fmt"
)
func hoved-(){
type Bilkonstruksjon {
 Merkestreng
 Modellstreng
 Pris int
 }
 val := Bil{Merke: "Mercedes", Modell: "Benz", Pris: 50 000}
 res, _ := json. Marshal (val)
fmt.Skriv ut(streng(res))
}

Denne koden produserer utdata:

De Merke, Modell, og Pris felt av Bil må begynne med store bokstaver, eller Marskalk vil ikke kunne konvertere dem. Dette resulterer i at JSON-utdatafeltene også starter med store bokstaver. Men hva om du vil at navnene skal begynne med små bokstaver i JSON, eller hvis du vil endre navn på et felt helt? Det er der struct-taggene kommer inn. Her er et eksempel:

pakke hoved-
import (
"koding/json"
"fmt"
)
func hoved-(){
type Bilkonstruksjon {
 ID int `json:"-"`
 Merkestreng `json:"type"`
 Modellstreng `json:"modell"`
 Pris int `json:"pris"`
 }
 val := Bil{ID: 0, merke: "Mercedes", Modell: "Benz", Pris: 50 000}
 res, _ := json. Marshal (val)
fmt.Skriv ut(streng(res))
}

Denne koden introduserer et nytt ID-felt som Marskalk utelater fra JSON-utdata via en struct-tag. Koden bruker også struct-tagger for å gi nytt navn til de andre struct-feltene. Her er programmets utgang:

Som du kan se, blir delen av struct-taggen som følger "json:" navnet på feltet i Marshals utdata. Det er ett unntak: hvis det er strengen "-", utelater Marshal det feltet fra utdataene. Du kan lese mer om Marshal og struct tags i Gå dokumentasjon.

Unmarshaling fra JSON i Go

Encoding/json-pakken gir også en unmarshaling-funksjon, kalt Unmarshal. Den har følgende funksjonssignatur:

func Unmarshal (data []byte, v grensesnitt{}) feil

I motsetning til Marskalk, Unmarshal returnerer ikke en verdi. I stedet godtar den JSON som en bit av byte i det første argumentet og lagrer deretter de konverterte dataene i objektet som det andre argumentet peker på. Unmarshal fungerer også med struct-tagger, men her forteller taggene Unmarshal hvilke JSON-felt samsvarer med hvilke struct-felt.

Når du skiller deg ut i et program, kan du kanskje hente data fra et API, men her skal du bruke dummy-data. Her er hvordan du bruker Unmarshal:

pakke hoved-
import (
"koding/json"
"fmt"
)


func hoved-(){
type Bilkonstruksjon {
 ID int `json:"-"`
 Merkestreng `json:"type"`
 Modellstreng `json:"modell"`
 Pris int `json:"pris"`
 }


jsonInput := `{
"type": "Toyota",
"modell": "Camry",
"pris": 2000
 }`


var jsonOutput bil
 feil := json. Unmarshal([]byte(jsonInput), &jsonOutput)


hvis feil != null {
 fmt. Println("JSON-dekodingsfeil!")
komme tilbake
 }
fmt.Skriv ut(jsonOutput)
}

Denne koden bruker samme biltype som det forrige eksempelet, og den deler opp et JSON-objekt til en struktur av typen Car, og skriver deretter ut dataene i strukturen. Når det kjøres, produserer programmet denne utgangen:

Dette viser at dummy-JSON-dataene ble dekket inn i jsonOutput struktur.

Go gjør det enkelt å jobbe med JSON

Med encoding/json-pakken er det like enkelt å jobbe med JSON i Go som to funksjonskall: Marshaland Unmarshal. Go lar deg også tilpasse prosessen med å sortere/avgrense JSON med struct-tagger.

Konvertering av data til JSON er en fin måte å dele dem med et annet program eller en annen prosess. Formatet er så universelt at JSON er så bærbart som mulig.