Hur man arbetar med YAML-filer i Go

YAML är ett populärt läsbart dataserialiseringsformat. Dataspråket är lämpligt för konfigurationsfiler, datautbyte och strukturerad datalagring.

Många Go-baserade projekt, inklusive Gqlgen och byggverktyg som Docker-compose, använder YAML-filer för konfiguration. Som Go-utvecklare kan du använda verktyg som yaml-paketet för att analysera och manipulera YAML-data.

Förstå en YAML-fil

YAML-filer (YAML Ain't Markup Language) består av nyckel-värdepar, listor och kapslade strukturer. YAML-syntax är designad för att vara visuellt tilltalande och lätt att läsa. Detta gör det till ett populärt val för konfigurationsfiler, med Kubernetes och annat orkestreringsverktyg med YAML.

Till skillnad från andra dataformat som XML och JSON, YAML förlitar sig på indrag för att representera hierarkin.

Så här kan du definiera grundläggande fält med YAML:

namn:JohnHind
ålder:30
e-post:[email protected]

Ett kolon separerar nyckeln från dess värde, som kan vara vilken giltig YAML-datatyp som helst inklusive strängar, siffror, booleaner eller kapslade strukturer.

Listor låter dig representera en samling värden. För att definiera en lista i YAML, använd ett bindestreck följt av ett mellanslag före varje objekt:

frukter:
-äpple
-banan
-orange

Här, frukter är nyckeln, och de avstavade linjerna definierar en lista med frukter.

YAML stöder också kapslade strukturer, vilket gör att du kan representera komplexa datahierarkier:

person:
namn:JohnHind
ålder:30
adress:
gata:123MainSt
stad:Vilken stad som helst
Land:USA

De person nyckel innehåller en annan uppsättning nyckel-värdepar, som bildar en kapslad struktur. De adress nyckel har sin egen uppsättning nyckel-värdepar.

Arbeta med YAML i Go

Go tillhandahåller inte inbyggd funktionalitet för YAML-filer, men det finns tredjepartspaket som gör det.

De jaml paket är ett populärt paket för att arbeta med YAML-filer. Det ger:

• Funktioner för att analysera och serialisera.
• Stöd för YAML-taggar.
• Omfattande YAML-specifikation.
• Finkornig kontroll över rangering och avmarshalling.
• Felhantering.
• Kompatibilitet med flera YAML-versioner.

Öppna din terminal och kör det här kommandot för att installera YAML-paketet för ditt projekt:

# installera version 3 av yaml-paketet
skaffa gopkg.in/yaml.v3

Efter installation av paketet kan du använda importera uttalande för att importera paketet till dina Go-filer.

importera"gopkg.in/yaml.v3"

Du kan välja flera YAML-versioner baserat på den version av YAML-specifikationen du vill använda.

Läsa och analysera YAML to Go-datastrukturer

En viktig uppgift du vill utföra är att analysera YAML to Go-datastrukturer. De jaml paketet tillhandahåller ett enkelt och bekvämt API för att göra detta.

Tänk på denna YAML-data:

# output.yaml
person:
namn:JohnHind
ålder:30
e-post:[email protected]

Du kan definiera en motsvarande struktur med matchande fältnamn för att analysera YAML-data till en Go-datastruktur med jaml paket.

// Person struct representerar personnyckeln i YAML.
typ Person struktur {
 namn sträng`yaml:"namn"`
 Ålder int`yaml:"ålder"`
 E-post sträng`yaml:"e-post"`
}

De jaml struct-taggar hjälper till att mappa YAML-nycklarna till struct-fälten under analysoperationen.

Så här kan du analysera YAML-data till en Go-datastruktur:

importera (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funchuvud() {
// läs filen output.yaml 
 data, fel := os. Läsfil("output.yaml")
om fel!= noll {
panik(fela)
 }

// skapa en personstruktur och deserialisera data till den strukturen
var person Person
om fel := yaml. Unmarshal (data, &person); fel!= noll {
panik(fela)
 }

// skriv ut fälten till konsolen
 fmt. Printf("Namn: %s\n", person. Namn)
 fmt. Printf("Ålder: %d\n", person. Ålder)
 fmt. Printf("E-post: %s\n", person. E-post)
}

De huvud funktionen läser output.yaml fil med ioutil paketets Läsfil fungera. Det skapar sedan en instans av Person struct och analyserar data till strukturen med Unmarshal metod för jaml paket. De huvud funktion skriver ut fälten från struct-instansen; här är resultatet:

Infoga data i en YAML-fil

Du kan använda Go-datastrukturer för att infoga data i YAML-filer. Så här kan du infoga data i en YAML-fil med en instans av Person struktur:

funchuvud() {
// Skapa en instans av personstrukturen med exempeldata
 person := Person{
 Namn: "John Doe",
 Ålder: 30,
 E-post: "[email protected]",
 }
// Serialisera personstrukturen till YAML-format
 data, err := yaml. Marskalk (&person)
om fel!= noll {
panik(fela)
 }
// Skriv den serialiserade YAML-datan till en fil med namnet "output.yaml"
 fel = os. WriteFile("output.yaml", data, 0644)
om fel!= noll {
panik(fela)
 }
 fmt. Println("Data skrivs till output.yaml")
}

De person variabel är en instans av Person strukturtyp. Använd Marskalk metod för jaml paket för att konvertera strukturen till YAML. Den tar in instansen av strukturen och returnerar YAML-representationen och ett fel.

Du kan använda WriteFile funktion av os paket för att skriva YAML-data till din fil (i det här fallet, output.yaml).

Efter en framgångsrik YAML-dataserialisering och skrivoperation, huvud funktionen skriver ut ett meddelande till konsolen.

Du kan samla och avskilja YAML till kartor som du gör med strukturer.

Här är ett exempel på att sortera och ta bort YAML-data med kartor:

paket huvud
importera (
"fmt"
"gopkg.in/yaml.v3"
)
funchuvud() {
// Data för marshaling
 data := Karta[sträng]gränssnitt{}{
"namn": "John Doe",
"ålder": 30,
"e-post": "[email protected]",
 }
// Sorterar data till YAML
 yamlData, err := yaml. Marskalk (data)
om fel!= noll {
 fmt. Println("Fel under rangering:", fel)
lämna tillbaka
 }
 fmt. Println("Marshaled YAML-data:")
 fmt. Println(sträng(yamlData))
// Dela upp YAML-data till en karta
var unmarshalledData Karta[sträng]gränssnitt{}
 fel = jaml. Unmarshal (yamlData, &unmarshalledData)
om fel!= noll {
 fmt. Println("Fel under avmarshalling:", fel)
lämna tillbaka
 }
 fmt. Println("\nOmarshalled data:")
 fmt. Println (unmarshalledData)
}

Processen är densamma som för strukturtyper, förutom att du använder kartor för datarepresentationen. De Unmarshal och Marskalk metoder fungerar för båda datatyperna.

Docker Compose använder YAML-filer för konfiguration

Att arbeta med YAML-filer i Go ger en kraftfull och flexibel metod för att hantera konfigurationsdata.

Ett framträdande användningsfall för YAML-filer är Docker Compose, där en YAML-fil fungerar som konfigurationen för att definiera och hantera Docker-applikationer med flera behållare.

Docker Compose utnyttjar enkelheten och läsbarheten hos YAML för att definiera tjänster, nätverk, volymer och andra komponenter i containeriserade applikationer för att göra containerorkestrering enkel.