Golang Marshal og Unmarshal

Marshaling refererer til å transformere et objekt til et spesifikt dataformat som er egnet for overføring.

JSON er et av de mest populære datautvekslingsformatene. Det er forenklet, menneskelig lesbar og veldig fleksibel. Det er et utmerket valg for APIer og mest dataoverføring. Enheten du har, bruker sannsynligvis JSON for å utføre en spesifikk oppgave.

I et slikt tilfelle er det viktig å lære å jobbe med JSON. I denne guiden lærer vi å jobbe.

Golang Marshal

Koding og avkoding av JSON -informasjon i Go er gitt av koding/JSON -pakken. Det er en del av standardbiblioteket; Derfor trenger du ikke å installere den.

Du må imidlertid importere den.

Econding/JSON -pakken koder for enhver datatype til en gyldig JSON -streng, som vi vil se i disse eksemplene.

Før du diskuterer hvordan du koder for GO -strukturer, la oss starte med grunnleggende datatyper.

JSON Marshal -funksjon

Følgende beskriver syntaks for marshalfunksjonen som definert i pakken.

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

Funksjonen tar hvilken som helst datatype som argument. Funksjonen returnerer en byte -skive, og det oppstår en feil under marskalprosessen.

Marshal int

Vi kan marsjere en heltalltype som vist i eksemplet nedenfor:

pakkehoved
import (
"koding/json"
"FMT"
"reflektere"
)
FUNCMAIN ()
I: = 100
Marshal_int, _: = JSON.Marshal (i)
// Sjekk type
fmt.Println ("før rollebesetning:", reflekterer.Typeof (marshal_int))
fmt.Println ("Etter rollebesetning:", Reflekter.Typeof (streng (marshal_int)))

I eksemplet over begynner vi med å importere de nødvendige pakkene. Vi trenger koding/json, FMT og refleksjonspakken i vårt eksempel.

Vi bruker JSON.Marshal () -metode til marskalk og heltallverdi. Du vil merke at funksjonen returnerer en Unint8 (et 8-bits usignert heltall) eller byte. Vi må kaste den til en streng som vist i utgangen nedenfor:

$ GO RUN MARSHALL.gå
Før rollebesetning: [] Uint8
Etter rollebesetning: streng

Dette returnerer en heltallstreng.

Marskalkstreng.

Vi kan marsjere en strengtype som vist i eksemplet nedenfor:

funcmarshal_str ()
Marshaled_str, _: = json.Marshal ("Linuxhint")
fmt.Println ("Marshaled String:", Marshaled_str)

Hvis vi kjører ovennevnte kode, bør vi få strengen marshaled inn i en skive byte som:

Marshaled String: [34 76 105 110 117 120 104 105 110 116 34]

Marshall Bool

Du kan også marskalk en boolsk type ved hjelp av marshalfunksjonen. Tenk på eksemplet nedenfor:

funcmarshal_bool ()
Marshaled_bool, _: = JSON.Marshal (falsk)
fmt.Println (Marshaled_bool)

Marshal Float

Marshal en flytende type som vist:

funcmarshal_float ()
Marshaled_Float, _: = JSON.Marshal (3.14159)
fmt.Println (Marshaled_Float)

Marshal -skive

Eksemplet nedenfor illustrerer hvordan du kan marsjere en skive i Go:

funcmarshal_slice ()
Slice_raw: = [] String "Microsoft", "Google", "Amazon"
Marshaled_slice, _: = json.Marshal (skive_raw)
fmt.Println (streng (marshaled_slice))

Marskalkstruktur

For å marsjere en struktur i Go, bør du vurdere eksemplet nedenfor:

funcmarshal_struct ()
type ansattstruktur
Full_name streng
Alder int
Pensjonert bool
Lønn Int

Marshal_struct, _: = JSON.Marshal (ansatt full_name: "John Doe", alder: 32, pensjonert: falsk, lønn: 140000)
fmt.Println (streng (marshal_struct))

Eksempelfunksjonen ovenfor illustrerer hvordan man marskalk en struktur type i go.

Den resulterende utgangen er som vist:

"Full_name": "John Doe", "Age": 32, "pensjonert": False, "Lønn": 140000

Ovennevnte representerer strukturen marskalket til en gyldig JSON -streng.

Golang Unmarshal

Unmarshal er det motsatte av marskalk. Det lar deg konvertere byte -data til den opprinnelige datastrukturen.

I GO blir Unmarshaling håndtert av JSON.Unmarshal () -metode.

Tenk på et eksempel JSON -streng som:

"Full_name": "John Doe", "Age": 32, "pensjonert": False, "Lønn": 140000

La oss starte med å lage en struktur for å matche byte -koden etter å ha utført Unmarshal.

Skriv brukerstruktur
Full_name String 'json: "full_name"'
Aldersstreng 'Json: "Alder"'
Pensjonert bool 'Json: "Pensjonert"'
Lønn Int 'JSON: "Lønn"'

Neste trinn er å opprette JSON -strengen til byte -kode. Når vi har byte -koden, kan vi unmarshal den til en struktur.

user_info_bytes: = [] byte (user_info)

Når vi har byte -koden, kan vi unmarshall den til struct.

var ansattes bruker
JSON.Unmarshal (user_info_bytes, og ansatt)

Når vi har strukturen, kan vi få tilgang til verdiene som:

fmt.Println (ansatt.Fullt navn)
fmt.Println (ansatt.Alder)
fmt.Println (ansatt.Pensjonert)
fmt.Println (ansatt.Lønn)

Ovennevnte kode skal returnere:

John Doe
32
falsk
140000

Den fulle kildekoden er som vist nedenfor:

func unmarshal_struct ()
user_info: = '"full_name": "John doe", "alder": 32, "pensjonert": falsk, "lønn": 140000'
Skriv brukerstruktur
Full_name String 'json: "full_name"'
Aldersstreng 'Json: "Alder"'
Pensjonert bool 'Json: "Pensjonert"'
Lønn Int 'JSON: "Lønn"'

user_info_bytes: = [] byte (user_info)
var ansattes bruker
JSON.Unmarshal (user_info_bytes, og ansatt)
fmt.Println (ansatt.Fullt navn)
fmt.Println (ansatt.Alder)
fmt.Println (ansatt.Pensjonert)
fmt.Println (ansatt.Lønn)

Konklusjon

Marshal og unmarshal representerer et viktig krav til datatransformasjon. Som programmerere er det viktig å gjøre oss kjent med hvordan vi skal utføre slike operasjoner. Denne opplæringen tjener det formålet med letthet.

Takk for at du leser og lykkelig koding!