Mithilfe von YAML können Sie Go-Programme schreiben, die mithilfe des Datenformats mit anderen zusammenarbeiten. Es ist für Menschen lesbar und daher einfach zu handhaben.

YAML ist ein beliebtes, für Menschen lesbares Datenserialisierungsformat. Die Datensprache eignet sich für Konfigurationsdateien, Datenaustausch und strukturierte Datenspeicherung.

Viele Go-basierte Projekte, darunter Gqlgen und Build-Tools wie Docker-Compose, verwenden YAML-Dateien zur Konfiguration. Als Go-Entwickler können Sie Tools wie das Yaml-Paket verwenden, um YAML-Daten zu analysieren und zu bearbeiten.

Eine YAML-Datei verstehen

YAML-Dateien (YAML Ain't Markup Language) bestehen aus Schlüssel-Wert-Paaren, Listen und verschachtelten Strukturen. Die YAML-Syntax ist optisch ansprechend und leicht lesbar gestaltet. Dies macht es zu einer beliebten Wahl für Konfigurationsdateien, mit Kubernetes und anderen Orchestrierungstools mit YAML.

Im Gegensatz zu anderen Datenformaten wie XML und JSON, YAML basiert auf Einrückungen zur Darstellung der Hierarchie.

instagram viewer

So können Sie grundlegende Felder mit YAML definieren:

Name:JohnDamhirschkuh
Alter:30
Email:[email protected]

Ein Doppelpunkt trennt den Schlüssel von seinem Wert, der ein beliebiger gültiger YAML-Datentyp sein kann, einschließlich Zeichenfolgen, Zahlen, booleschen Werten oder verschachtelten Strukturen.

Mit Listen können Sie eine Sammlung von Werten darstellen. Um eine Liste in YAML zu definieren, verwenden Sie vor jedem Element einen Bindestrich gefolgt von einem Leerzeichen:

Früchte:
-Apfel
-Banane
-orange

Hier, Früchte ist der Schlüssel, und die getrennten Zeilen definieren eine Liste von Früchten.

YAML unterstützt auch verschachtelte Strukturen, sodass Sie komplexe Datenhierarchien darstellen können:

Person:
Name:JohnDamhirschkuh
Alter:30
Adresse:
Straße:123HauptsächlichSt
Stadt:Irgendeine Stadt
Land:USA

Der Person key enthält einen weiteren Satz von Schlüssel-Wert-Paaren, die eine verschachtelte Struktur bilden. Der Adresse Der Schlüssel verfügt über einen eigenen Satz von Schlüssel-Wert-Paaren.

Arbeiten mit YAML in Go

Go bietet keine integrierte Funktionalität für YAML-Dateien, es gibt jedoch Pakete von Drittanbietern, die dies tun.

Der Yaml Paket ist ein beliebtes Paket für die Arbeit mit YAML-Dateien. Es bietet:

  • Parsing- und Serialisierungsfunktionen.
  • Unterstützung für YAML-Tags.
  • Umfassende Einhaltung der YAML-Spezifikation.
  • Fein abgestimmte Kontrolle über das Marshalling und Unmarshalling.
  • Fehlerbehandlung.
  • Kompatibilität mit mehreren YAML-Versionen.

Öffnen Sie Ihr Terminal und führen Sie diesen Befehl aus, um das YAML-Paket für Ihr Projekt zu installieren:

# Version 3 des Yaml-Pakets installieren
Holen Sie sich gopkg.in/yaml.v3

Nach der Installation des Pakets können Sie das verwenden importieren Anweisung, um das Paket in Ihre Go-Dateien zu importieren.

importieren„gopkg.in/yaml.v3“

Sie können mehrere YAML-Versionen basierend auf der Version der YAML-Spezifikation auswählen, die Sie verwenden möchten.

Lesen und Parsen von YAML-to-Go-Datenstrukturen

Eine wichtige Aufgabe, die Sie ausführen müssen, ist das Parsen von YAML-to-Go-Datenstrukturen. Der Yaml Das Paket stellt hierfür eine einfache und praktische API bereit.

Betrachten Sie diese YAML-Daten:

# Ausgabe.yaml
Person:
Name:JohnDamhirschkuh
Alter:30
Email:[email protected]

Sie können eine entsprechende Struktur mit passenden Feldnamen definieren, um die YAML-Daten mit dem in eine Go-Datenstruktur zu analysieren Yaml Paket.

// Personenstruktur stellt den Personenschlüssel in YAML dar.
Typ Person Struktur {
 Name Zeichenfolge`yaml:"name"`
 Alter int`yaml:"Alter"`
 Email Zeichenfolge`yaml:"email"`
}

Der Yaml Struktur-Tags helfen dabei, die YAML-Schlüssel während des Parsing-Vorgangs den Strukturfeldern zuzuordnen.

So können Sie die YAML-Daten in eine Go-Datenstruktur analysieren:

importieren (
„fmt“
„gopkg.in/yaml.v3“
„os“
)
Funktionhauptsächlich() {
// die Datei „output.yaml“ lesen 
 Daten, Fehler := os. ReadFile(„output.yaml“)


Wenn äh!= Null {
Panik(irren)
 }

// eine Personenstruktur erstellen und die Daten in diese Struktur deserialisieren
var Person Person
Wenn ähm := yaml. Unmarshal (Daten, &person); äh!= Null {
Panik(irren)
 }

// die Felder auf der Konsole ausgeben
 fmt. Druckenf(„Name: %s\n“, Person. Name)
 fmt. Druckenf(„Alter: %d\n“, Person. Alter)
 fmt. Druckenf(„E-Mail: %s\n“, Person. Email)
}

Der hauptsächlich Funktion liest die Ausgabe.yaml Datei mit der ioutil Pakete ReadFile Funktion. Anschließend wird eine Instanz von erstellt Person struct und analysiert die Daten in die Struktur mit dem Unmarshal Methode der Yaml Paket. Der hauptsächlich Funktion druckt die Felder aus der Strukturinstanz; hier ist das Ergebnis:

Einfügen von Daten in eine YAML-Datei

Sie können Go-Datenstrukturen verwenden, um Daten in YAML-Dateien einzufügen. So können Sie Daten mit einer Instanz von in eine YAML-Datei einfügen Person Struktur:

Funktionhauptsächlich() {
// Erstellen Sie eine Instanz der Person-Struktur mit Beispieldaten
 Person := Person{
 Name: "John Doe",
 Alter: 30,
 Email: „[email protected]“,
 }
// Serialisieren Sie die Personenstruktur in das YAML-Format
 Daten, ähm := yaml. Marschall(&Person)


Wenn äh!= Null {
Panik(irren)
 }


// Schreiben Sie die serialisierten YAML-Daten in eine Datei mit dem Namen „output.yaml“
 err = os. WriteFile(„output.yaml“, Daten, 0644)


Wenn äh!= Null {
Panik(irren)
 }
 fmt. Println(„Daten werden in die Datei „output.yaml“ geschrieben“)
}

Der Person Variable ist eine Instanz von Person Strukturtyp. Benutzen Sie die Marschall Methode der Yaml Paket zum Konvertieren der Struktur in YAML. Es nimmt die Instanz der Struktur auf und gibt die YAML-Darstellung und einen Fehler zurück.

Du kannst den... benutzen WriteFile Funktion der os Paket, um die YAML-Daten in Ihre Datei zu schreiben (in diesem Fall Ausgabe.yaml).

Nach einer erfolgreichen YAML-Datenserialisierung und einem Schreibvorgang wird die hauptsächlich Funktion gibt eine Nachricht an die Konsole aus.

Sie können YAML wie bei Strukturen in Karten marshalieren und unmarshalieren.

Hier ist ein Beispiel für das Marshalling und Unmarshalling von YAML-Daten mit Karten:

Paket hauptsächlich
importieren (
„fmt“
„gopkg.in/yaml.v3“
)


Funktionhauptsächlich() {
// Daten für das Marshalling
 Daten := Karte[Zeichenfolge]Schnittstelle{}{
"Name": "John Doe",
"Alter": 30,
"Email": „[email protected]“,
 }


// Marshallen der Daten in YAML
 yamlData, err := yaml. Marschall (Daten)


Wenn äh!= Null {
 fmt. Println(„Fehler beim Marshalling:“, irren)
zurückkehren
 }


 fmt. Println(„Marshallte YAML-Daten:“)
 fmt. Println(Zeichenfolge(yamlData))


// Unmarshalling der YAML-Daten in eine Karte
var unmarshalledData Karte[Zeichenfolge]Schnittstelle{}
 err = yaml. Unmarshal (yamlData, &unmarshalledData)


Wenn äh!= Null {
 fmt. Println(„Fehler beim Unmarshalling:“, irren)
zurückkehren
 }
 fmt. Println(„\nNicht gemarshallte Daten:“)
 fmt. Println (unmarshalledData)
}

Der Vorgang ist der gleiche wie bei Strukturtypen, außer dass Sie Karten für die Datendarstellung verwenden. Der Unmarshal Und Marschall Methoden funktionieren für beide Datentypen.

Docker Compose verwendet YAML-Dateien zur Konfiguration

Die Arbeit mit YAML-Dateien in Go bietet einen leistungsstarken und flexiblen Ansatz zur Verwaltung von Konfigurationsdaten.

Ein prominenter Anwendungsfall für YAML-Dateien ist Docker Compose, bei dem eine YAML-Datei als Konfiguration für die Definition und Verwaltung von Docker-Anwendungen mit mehreren Containern dient.

Docker Compose nutzt die Einfachheit und Lesbarkeit von YAML, um Dienste, Netzwerke, Volumes und andere Komponenten von Containeranwendungen zu definieren und so die Container-Orchestrierung zu vereinfachen.