Werken met YAML-bestanden in Go

YAML is een populair, door mensen leesbaar formaat voor gegevensserialisatie. De gegevenstaal is geschikt voor configuratiebestanden, gegevensuitwisseling en gestructureerde gegevensopslag.

Veel op Go gebaseerde projecten, waaronder Gqlgen en bouwtools zoals Docker-compose, gebruiken YAML-bestanden voor configuratie. Als Go-ontwikkelaar kun je tools zoals het yaml-pakket gebruiken om YAML-gegevens te ontleden en te manipuleren.

Een YAML-bestand begrijpen

YAML-bestanden (YAML Ain't Markup Language) bestaan ​​uit sleutel-waardeparen, lijsten en geneste structuren. De YAML-syntaxis is ontworpen om visueel aantrekkelijk en gemakkelijk te lezen te zijn. Dit maakt het een populaire keuze voor configuratiebestanden, met Kubernetes en andere orkestratietools met behulp van YAML.

In tegenstelling tot andere gegevensformaten zoals XML en JSON, vertrouwt YAML op inspringing om hiërarchie weer te geven.

Zo definieert u basisvelden met YAML:

naam:JohnDoe
leeftijd:30
e-mail:[email protected]

Een dubbele punt scheidt de sleutel van zijn waarde, die elk geldig YAML-gegevenstype kan zijn, inclusief tekenreeksen, getallen, booleans of geneste structuren.

Met lijsten kunt u een verzameling waarden vertegenwoordigen. Gebruik een koppelteken gevolgd door een spatie voor elk item om een ​​lijst in YAML te definiëren:

fruit:
-appel
-banaan
-oranje

Hier, vruchten is de sleutel, en de afgebroken lijnen definiëren een lijst met vruchten.

YAML ondersteunt ook geneste structuren, waardoor u complexe gegevenshiërarchieën kunt weergeven:

persoon:
naam:JohnDoe
leeftijd:30
adres:
straat:123VoornaamstSt
stad:Elke stad
land:VS

De persoon key bevat nog een set sleutel-waardeparen, die een geneste structuur vormen. De adres key heeft zijn eigen set sleutel-waardeparen.

Werken met YAML in Go

Go biedt geen ingebouwde functionaliteit voor YAML-bestanden, maar er zijn pakketten van derden die dat wel doen.

De yaml pakket is een populair pakket voor het werken met YAML-bestanden. Het zorgt voor:

• Parsing- en serialisatiefuncties.
• Ondersteuning voor YAML-tags.
• Uitgebreide naleving van YAML-specificaties.
• Fijnmazige controle over rangeren en demarshallen.
• Foutafhandeling.
• Compatibiliteit met meerdere YAML-versies.

Open uw terminal en voer deze opdracht uit om het YAML-pakket voor uw project te installeren:

# installeer versie 3 van het yaml-pakket
ga naar gopkg.in/yaml.v3

Na installatie van het pakket kunt u de importeren instructie om het pakket in uw Go-bestanden te importeren.

importeren"gopkg.in/yaml.v3"

U kunt meerdere YAML-versies kiezen op basis van de versie van de YAML-specificatie die u wilt gebruiken.

Lezen en parseren van YAML to Go-gegevensstructuren

Een essentiële taak die u wilt uitvoeren, is het parseren van YAML to Go-gegevensstructuren. De yaml pakket biedt een eenvoudige, handige API om dit te doen.

Beschouw deze YAML-gegevens:

# uitvoer.yaml
persoon:
naam:JohnDoe
leeftijd:30
e-mail:[email protected]

U kunt een overeenkomstige structuur definiëren met overeenkomende veldnamen om de YAML-gegevens te ontleden in een Go-gegevensstructuur met de yaml pakket.

// Person struct vertegenwoordigt de persoonssleutel in YAML.
type Persoon structuur {
 Naam snaar`yaml:"naam"`
 Leeftijd int`yaml:"leeftijd"`
 E-mail snaar`yaml:"e-mail"`
}

De yaml struct-tags helpen bij het toewijzen van de YAML-sleutels aan de struct-velden tijdens de parseerbewerking.

Zo kunt u de YAML-gegevens ontleden in een Go-gegevensstructuur:

importeren (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funcvoornaamst() {
// lees het bestand output.yaml 
 gegevens, fout := os. LeesBestand("output.yaml")
als fout!= nihil {
paniek(fout)
 }

// maak een persoonsstructuur en deserialiseer de gegevens naar die structuur
var persoon Persoon
als fout := yaml. Unmarshal (gegevens, &persoon); fout!= nihil {
paniek(fout)
 }

// print de velden naar de console
 fmt. Afdrukkenf("Naam: %s\n", persoon. Naam)
 fmt. Afdrukkenf("Leeftijd: %d\n", persoon. Leeftijd)
 fmt. Afdrukkenf("E-mail: %s\n", persoon. e-mail)
}

De voornaamst functie leest de uitvoer.yaml bestand met de ioutil pakketjes LeesBestand functie. Het creëert dan een instantie van de Persoon struct en ontleedt de gegevens in de struct met de onmaarschalk methode van de yaml pakket. De voornaamst functie drukt de velden af ​​van de instantie struct; hier is het resultaat:

Gegevens invoegen in een YAML-bestand

U kunt Go-gegevensstructuren gebruiken om gegevens in YAML-bestanden in te voegen. Hier leest u hoe u gegevens kunt invoegen in een YAML-bestand met een instantie van het Persoon structuur:

funcvoornaamst() {
// Maak een instantie van de Person-structuur met voorbeeldgegevens
 persoon := Persoon{
 Naam: "John Doe",
 Leeftijd: 30,
 E-mail: "[email protected]",
 }
// Serialiseer de persoonsstructuur in YAML-indeling
 gegevens, fout := yaml. Maarschalk(&persoon)
als fout!= nihil {
paniek(fout)
 }
// Schrijf de geserialiseerde YAML-gegevens naar een bestand met de naam "output.yaml"
 fout = os. SchrijfBestand("output.yaml", gegevens, 0644)
als fout!= nihil {
paniek(fout)
 }
 fmt. Println("Gegevens geschreven naar output.yaml")
}

De persoon variabele is een instantie van de Persoon struct type. Gebruik de Maarschalk methode van de yaml pakket om de structuur naar YAML te converteren. Het neemt de instantie van de struct over en retourneert de YAML-representatie en een fout.

U kunt de SchrijfBestand functie van de os pakket om de YAML-gegevens naar uw bestand te schrijven (in dit geval uitvoer.yaml).

Na een succesvolle YAML-gegevensserialisatie en schrijfbewerking, wordt het voornaamst functie drukt een bericht af naar de console.

U kunt YAML in kaarten rangschikken en ongedaan maken, net als bij structs.

Hier is een voorbeeld van het rangschikken en ongedaan maken van YAML-gegevens met kaarten:

pakket voornaamst
importeren (
"fmt"
"gopkg.in/yaml.v3"
)
funcvoornaamst() {
// Gegevens voor rangeren
 gegevens := kaart[snaar]koppel{}{
"naam": "John Doe",
"leeftijd": 30,
"e-mail": "[email protected]",
 }
// Verzamelen van de gegevens in YAML
 yamlData, fout := yaml. Maarschalk (gegevens)
als fout!= nihil {
 fmt. Println("Fout tijdens rangeren:", fout)
opbrengst
 }
 fmt. Println("Gebundelde YAML-gegevens:")
 fmt. Println(snaar(yamlData))
// Unmarshalling van de YAML-gegevens in een kaart
var unmarshalledData kaart[snaar]koppel{}
 fout = yaml. Unmarshal (yamlData, &unmarshalledData)
als fout!= nihil {
 fmt. Println("Fout tijdens het demarshallen:", fout)
opbrengst
 }
 fmt. Println("\nNiet-gemarshalleerde gegevens:")
 fmt. Println (unmarshalledData)
}

Het proces is hetzelfde als voor struct typen, behalve dat u kaarten gebruikt voor de gegevensrepresentatie. De onmaarschalk En Maarschalk methoden werken voor beide gegevenstypen.

Docker Compose gebruikt YAML-bestanden voor configuratie

Werken met YAML-bestanden in Go biedt een krachtige en flexibele aanpak voor het beheren van configuratiegegevens.

Een prominente use-case voor YAML-bestanden is Docker Compose, waarbij een YAML-bestand dient als configuratie voor het definiëren en beheren van Docker-toepassingen met meerdere containers.

Docker Compose maakt gebruik van de eenvoud en leesbaarheid van YAML om services, netwerken, volumes en andere componenten van gecontaineriseerde applicaties te definiëren om containerorkestratie eenvoudig te maken.