JSON (JavaScript Object Notation) er et meget alsidigt og meget populært dataformat. Det bruges ofte til kommunikation mellem webapps og også som en bekvem måde at gemme store mængder strukturerede applikationsdata på.

JSON er så nyttig, at næsten alle moderne programmeringssprog giver indbygget support til at arbejde med det, inklusive Go.

Arbejder med JSON i Go

Du kan opdele det meste af det arbejde, du skal udføre med JSON, i to generelle kategorier: marshaling og unmarshaling. Wikipedia definerer marshaling som:

Inden for datalogi er marshaling processen med at transformere hukommelsesrepræsentationen af ​​et objekt til et dataformat, der er egnet til lagring eller transmission. Det bruges typisk, når data skal flyttes mellem forskellige dele af et computerprogram eller fra et program til et andet.

I enklere vendinger er marshaling processen med at konvertere data gemt i en variabel til en form, der er lettere at overføre til et andet program. Unmarshaling er den omvendte proces: det involverer at tage data formateret til transport og konvertere dem til en form, der er nemmere for dit program at bruge.

instagram viewer

Ved at bruge Go kan du samle indfødte datastrukturer ind i JSON. Og du kan udføre den omvendte handling ved at opdele JSON-data til Go-variabler.

Marshaling til JSON i Go

Go giver encoding/json-pakke for at gøre det nemt for dig at arbejde med JSON. Denne pakke indeholder adskillige funktioner, men den du skal bruge til marshaling er Marskal fungere. Marskal har følgende funktionssignatur:

func marskal (v interface{}) ([]byte, fejl)

Det betyder at Marskal accepterer en parameter af enhver datatype og returnerer to værdier: et udsnit af bytes og en fejl. Du ringer med andre ord Marskal med en Go-værdi, og den konverterer den til JSON og returnerer JSON-ækvivalenten. Hvis den støder på en fejl under konverteringsprocessen, returnerer den fejlen og et tomt udsnit.

Her er et kodeeksempel, der bruger Marskal at konvertere et kort til JSON. For at køre dette eksempel er alt hvad du behøver at oprette en Go-fil i din foretrukne kodeeditor, eller brug Gå på legepladsen:

pakke vigtigste
importere (
"kodning/json"
"fmt"
)


func vigtigste(){
 val := kort[streng]int{
"John": 25,
"mary": 19,
"adam": 5,
 }
res, _ := json. Marshal (val)
fmt.Println(snor(res))
}

Hvis du kører den kode, udsender den følgende:

Som nævnt før, kan du samle enhver type Go-data til JSON, selvom du i det virkelige liv normalt vil samle strukturer. På grund af dette giver Go en funktion kaldet struct-tags, så du kan give dem Marskal ekstra instruktioner til at konvertere dine strukturer.

Et struct-tag er en streng, du inkluderer i din struct-deklaration ved siden af ​​datatypen for et felt. Med strukturmærker kan du justere vejen Marskal behandler det felt, tagget tilhører. Du kan bruge struct-tags til at omdøbe et felt i JSON-outputtet eller endda udelade det helt. Strukturmærker (det Marskal genkender) start med understrengen "json:".

Som et eksempel, lad os sige, at du har en struktur Bil der repræsenterer nogle oplysninger om en bil. Her er koden til at oprette en Bil og samle det til JSON:

pakke vigtigste
importere (
"kodning/json"
"fmt"
)
func vigtigste(){
type Bilkonstruktion {
 Mærkestreng
 Model streng
 Pris int
 }
 val := Bil{Mærke: "Mercedes", Model: "Benz", Pris: 50000}
 res, _ := json. Marshal (val)
fmt.Println(snor(res))
}

Denne kode producerer output:

Det Mærke, Model, og Pris felter af Bil skal starte med store bogstaver, eller Marskal vil ikke være i stand til at konvertere dem. Dette resulterer i, at JSON-outputfelterne også starter med store bogstaver. Men hvad hvis du vil have navnene til at starte med små bogstaver i JSON, eller hvis du vil omdøbe et felt helt? Det er her struct-taggene kommer ind. Her er et eksempel:

pakke vigtigste
importere (
"kodning/json"
"fmt"
)
func vigtigste(){
type Bilkonstruktion {
 ID int `json:"-"`
 Mærkestreng `json:"type"`
 Modelstreng `json:"model"`
 Pris int `json:"pris"`
 }
 val := Bil{ID: 0, Mærke: "Mercedes", Model: "Benz", Pris: 50000}
 res, _ := json. Marshal (val)
fmt.Println(snor(res))
}

Denne kode introducerer et nyt ID-felt, der Marskal udelader fra JSON-outputtet via et struct-tag. Koden bruger også struct-tags til at omdøbe de andre struct-felter. Her er programmets output:

Som du kan se, bliver den del af struct-tagget efter "json:" navnet på feltet i Marshals output. Der er én undtagelse: hvis det er strengen "-", udelader Marshal det felt fra outputtet. Du kan læse mere om Marshal og struct tags i Gå til dokumentation.

Unmarshaling fra JSON i Go

Encoding/json-pakken giver også en unmarshaling-funktion, kaldet Umarskal. Den har følgende funktionssignatur:

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

I modsætning til Marskal, Umarskal returnerer ikke en værdi. I stedet accepterer den JSON som et udsnit af bytes i det første argument og gemmer derefter de konverterede data i objektet, der peges på af dets andet argument. Umarskal fungerer også med struct-tags, men her fortæller taggene Umarskal hvilke JSON-felter matcher hvilke struct-felter.

Når du skiller dig ud i et program, kan du evt hente data fra en API, men her skal du bruge dummy-data. Sådan bruger du Umarskal:

pakke vigtigste
importere (
"kodning/json"
"fmt"
)


func vigtigste(){
type Bilkonstruktion {
 ID int `json:"-"`
 Mærkestreng `json:"type"`
 Modelstreng `json:"model"`
 Pris int `json:"pris"`
 }


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


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


hvis fejl != nul {
 fmt. Println("JSON-afkodningsfejl!")
Vend tilbage
 }
fmt.Println(jsonOutput)
}

Denne kode bruger den samme biltype som det foregående eksempel, og den opdeler et JSON-objekt til en struktur af typen Car og udskriver derefter dataene i strukturen. Når programmet køres, producerer dette output:

Dette viser, at dummy JSON-dataene med succes blev unmarshaled i jsonOutput struktur.

Go gør det nemt at arbejde med JSON

Med encoding/json-pakken er arbejdet med JSON i Go så simpelt som to funktionskald: Marshaland Unmarshal. Go giver dig også mulighed for at tilpasse processen med at sortere/udskille JSON med struct-tags.

Konvertering af data til JSON er en fantastisk måde at dele dem med et andet program eller en anden proces. Formatet er så universelt, at JSON er så bærbart som muligt.