Sådan arbejder du med YAML-filer i Go

YAML er et populært, menneskeligt læsbart dataserialiseringsformat. Datasproget er velegnet til konfigurationsfiler, dataudveksling og struktureret datalagring.

Mange Go-baserede projekter, inklusive Gqlgen og byggeværktøjer som Docker-compose, bruger YAML-filer til konfiguration. Som en Go-udvikler kan du bruge værktøjer som yaml-pakken til at parse og manipulere YAML-data.

Forstå en YAML-fil

YAML-filer (YAML Ain't Markup Language) består af nøgleværdi-par, lister og indlejrede strukturer. YAML-syntaks er designet til at være visuelt tiltalende og let at læse. Dette gør det til et populært valg til konfigurationsfiler, med Kubernetes og andre orkestreringsværktøjer ved hjælp af YAML.

I modsætning til andre dataformater som XML og JSON, YAML er afhængig af indrykning for at repræsentere hierarki.

Sådan kan du definere grundlæggende felter med YAML:

navn:JohnDoe
alder:30
e-mail:[email protected]

Et kolon adskiller nøglen fra dens værdi, som kan være enhver gyldig YAML-datatype inklusive strenge, tal, booleaner eller indlejrede strukturer.

Lister giver dig mulighed for at repræsentere en samling af værdier. For at definere en liste i YAML skal du bruge en bindestreg efterfulgt af et mellemrum før hvert element:

frugter:
-æble
-banan
-orange

Her, frugter er nøglen, og bindestreger definerer en liste over frugter.

YAML understøtter også indlejrede strukturer, så du kan repræsentere komplekse datahierarkier:

person:
navn:JohnDoe
alder:30
adresse:
gade:123HovedSt
by:Anytown
Land:USA

Det person nøgle indeholder et andet sæt nøgleværdi-par, der danner en indlejret struktur. Det adresse nøgle har sit eget sæt nøgleværdi-par.

Arbejde med YAML i Go

Go giver ikke indbygget funktionalitet til YAML-filer, men det er der tredjepartspakker, der gør.

Det yaml pakke er en populær pakke til at arbejde med YAML-filer. Det giver:

• Parsing og serialiseringsfunktioner.
• Understøttelse af YAML-tags.
• Omfattende overholdelse af YAML-specifikationer.
• Finmasket kontrol med rangering og afmarshallering.
• Fejlhåndtering.
• Kompatibilitet med flere YAML-versioner.

Åbn din terminal og kør denne kommando for at installere YAML-pakken til dit projekt:

# installer version 3 af yaml-pakken
gå hen til gopkg.in/yaml.v3

Efter installation af pakken kan du bruge importere erklæring for at importere pakken til dine Go-filer.

importere"gopkg.in/yaml.v3"

Du kan vælge flere YAML-versioner baseret på den version af YAML-specifikationen, du vil bruge.

Læsning og parsing af YAML to Go-datastrukturer

En væsentlig opgave, du ønsker at udføre, er at parse YAML to Go-datastrukturer. Det yaml pakken giver en enkel, praktisk API til at gøre dette.

Overvej disse YAML-data:

# output.yaml
person:
navn:JohnDoe
alder:30
e-mail:[email protected]

Du kan definere en tilsvarende struktur med matchende feltnavne for at parse YAML-dataene til en Go-datastruktur med yaml pakke.

// Person struct repræsenterer personnøglen i YAML.
type Person struktur {
 Navn snor`yaml:"navn"`
 Alder int`yaml:"alder"`
 E-mail snor`yaml:"e-mail"`
}

Det yaml struct-tags hjælper med at tilknytte YAML-nøglerne til struct-felterne under parsing-operationen.

Sådan kan du parse YAML-dataene til en Go-datastruktur:

importere (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funcvigtigste() {
// læs filen output.yaml 
 data, fejl := os. Læs Fil("output.yaml")
hvis fejl!= nul {
panik(fejl)
 }

// opret en personstruktur og deserialiser dataene til den struktur
var person Person
hvis fejl := jaml. Unmarshal (data, &person); fejl!= nul {
panik(fejl)
 }

// udskriv felterne til konsollen
 fmt. Printf("Navn: %s\n", person. Navn)
 fmt. Printf("Alder: %d\n", person. Alder)
 fmt. Printf("E-mail: %s\n", person. e-mail)
}

Det vigtigste funktionen læser output.yaml fil med ioutil pakkens Læs Fil fungere. Det opretter derefter en forekomst af Person struct og parser dataene ind i structen med Umarskal metoden til yaml pakke. Det vigtigste funktion udskriver felterne fra struct-forekomsten; her er resultatet:

Indsættelse af data i en YAML-fil

Du kan bruge Go-datastrukturer til at indsætte data i YAML-filer. Sådan kan du indsætte data til en YAML-fil med en forekomst af Person struktur:

funcvigtigste() {
// Opret en forekomst af Person-strukturen med eksempeldata
 person := person{
 Navn: "John Doe",
 Alder: 30,
 E-mail: "[email protected]",
 }
// Serialiser personstrukturen til YAML-format
 data, fejl := yaml. Marshal (&person)
hvis fejl!= nul {
panik(fejl)
 }
// Skriv de serialiserede YAML-data til en fil med navnet "output.yaml"
 fejl = os. SkrivFil("output.yaml", data, 0644)
hvis fejl!= nul {
panik(fejl)
 }
 fmt. Println("Data skrevet til output.yaml")
}

Det person variabel er en forekomst af Person struct type. Brug Marskal metoden til yaml pakke for at konvertere strukturen til YAML. Det tager instansen af ​​strukturen og returnerer YAML-repræsentationen og en fejl.

Du kan bruge Skriv fil funktion af os pakke til at skrive YAML-dataene til din fil (i dette tilfælde, output.yaml).

Efter en vellykket YAML-dataserialisering og skriveoperation, vigtigste funktion udskriver en besked til konsollen.

Du kan samle og udskille YAML til kort, som du gør med strukturer.

Her er et eksempel på rangering og unmarshalling af YAML-data med kort:

pakke vigtigste
importere (
"fmt"
"gopkg.in/yaml.v3"
)
funcvigtigste() {
// Data til marshaling
 data := kort[snor]interface{}{
"navn": "John Doe",
"alder": 30,
"e-mail": "[email protected]",
 }
// Marsharing af data til YAML
 yamlData, fejl := yaml. Marshal (data)
hvis fejl!= nul {
 fmt. Println("Fejl under rangering:", fejl)
Vend tilbage
 }
 fmt. Println("Marshaled YAML data:")
 fmt. Println(snor(yamlData))
// Oprettelse af YAML-data til et kort
var unmarshalledData kort[snor]interface{}
 fejl = yaml. Unmarshal (yamlData, &unmarshalledData)
hvis fejl!= nul {
 fmt. Println("Fejl under unmarshalling:", fejl)
Vend tilbage
 }
 fmt. Println("\nIkke-marshallerede data:")
 fmt. Println (unmarshalledData)
}

Processen er den samme som for strukturtyper, bortset fra at du bruger kort til datarepræsentationen. Det Umarskal og Marskal metoder virker for begge datatyper.

Docker Compose bruger YAML-filer til konfiguration

At arbejde med YAML-filer i Go giver en kraftfuld og fleksibel tilgang til styring af konfigurationsdata.

En fremtrædende brugssag for YAML-filer er Docker Compose, hvor en YAML-fil fungerer som konfigurationen til at definere og administrere Docker-applikationer med flere beholdere.

Docker Compose udnytter YAML's enkelhed og læsbarhed til at definere tjenester, netværk, volumener og andre komponenter i containeriserede applikationer for at gøre containerorkestrering let.