Cum să lucrați cu fișierele YAML în Go

YAML este un format popular de serializare a datelor care poate fi citit de om. Limbajul de date este potrivit pentru fișierele de configurare, schimbul de date și stocarea datelor structurate.

Multe proiecte bazate pe Go, inclusiv Gqlgen și instrumente de construcție precum Docker-compose, folosesc fișiere YAML pentru configurare. În calitate de dezvoltator Go, puteți folosi instrumente precum pachetul yaml pentru a analiza și manipula datele YAML.

Înțelegerea unui fișier YAML

Fișierele YAML (YAML Ain't Markup Language) constau din perechi cheie-valoare, liste și structuri imbricate. Sintaxa YAML este concepută pentru a fi atrăgătoare din punct de vedere vizual și ușor de citit. Acest lucru îl face o alegere populară pentru fișierele de configurare, cu Kubernetes și altele instrumente de orchestrare folosind YAML.

Spre deosebire de alte formate de date precum XML și JSON, YAML se bazează pe indentare pentru a reprezenta ierarhia.

Iată cum puteți defini câmpurile de bază cu YAML:

Nume:IoanCăprioară
vârstă:30
e-mail:[email protected]

Punctele două puncte separă cheia de valoarea acesteia, care poate fi orice tip de date YAML valid, inclusiv șiruri, numere, boolean sau structuri imbricate.

Listele vă permit să reprezentați o colecție de valori. Pentru a defini o listă în YAML, utilizați o cratimă urmată de un spațiu înaintea fiecărui element:

fructe:
-măr
-banană
-portocale

Aici, fructe este cheia, iar liniile cu cratime definesc o listă de fructe.

YAML acceptă, de asemenea, structuri imbricate, permițându-vă să reprezentați ierarhii complexe de date:

persoană:
Nume:IoanCăprioară
vârstă:30
abordare:
stradă:123PrincipalSf
oraș:Oricare oraș
țară:STATELE UNITE ALE AMERICII

The persoană cheia conține un alt set de perechi cheie-valoare, formând o structură imbricată. The abordare cheia are propriul set de perechi cheie-valoare.

Lucrul cu YAML în Go

Go nu oferă funcționalitate încorporată pentru fișierele YAML, dar există pachete terță parte care o fac.

The yaml pachet este un pachet popular pentru lucrul cu fișiere YAML. Oferă:

• Caracteristici de analizare și serializare.
• Suport pentru etichetele YAML.
• Conformitate cuprinzătoare cu specificațiile YAML.
• Control fin asupra repartizării și dezmembrarii.
• Eroare de manipulare.
• Compatibilitate cu mai multe versiuni YAML.

Deschideți terminalul și rulați această comandă pentru a instala pachetul YAML pentru proiectul dvs.:

# instalați versiunea 3 a pachetului yaml
du-te la gopkg.in/yaml.v3

După instalarea pachetului, puteți utiliza import declarație pentru a importa pachetul în fișierele Go.

import„gopkg.in/yaml.v3”

Puteți alege mai multe versiuni YAML în funcție de versiunea specificației YAML pe care doriți să o utilizați.

Citirea și analizarea structurilor de date YAML to Go

O sarcină esențială pe care veți dori să o efectuați este analizarea structurilor de date YAML to Go. The yaml pachetul oferă un API simplu și convenabil pentru a face acest lucru.

Luați în considerare aceste date YAML:

# output.yaml
persoană:
Nume:IoanCăprioară
vârstă:30
e-mail:[email protected]

Puteți defini o structură corespunzătoare cu nume de câmpuri potrivite pentru a analiza datele YAML într-o structură de date Go cu yaml pachet.

// Structura persoană reprezintă cheia persoană în YAML.
tip Persoană struct {
 Nume şir`yaml:"nume"`
 Vârstă int`yaml:"vârstă"`
 E-mail şir`yaml:"e-mail"`
}

The yaml Etichetele struct ajută la maparea cheilor YAML la câmpurile struct în timpul operației de analiză.

Iată cum puteți analiza datele YAML într-o structură de date Go:

import (
"fmt"
„gopkg.in/yaml.v3”
"os"
)
funcprincipal() {
// citește fișierul output.yaml 
 date, err := os. ReadFile(„output.yaml”)
dacă greș!= zero {
panică(eroare)
 }

// creează o structură persoană și deserializează datele în acea structură
var persoană Persoană
dacă err := yaml. Unmarshal (date, &persoana); greș!= zero {
panică(eroare)
 }

// tipăriți câmpurile în consolă
 fmt. Printf(„Nume: %s\n”, persoană. Nume)
 fmt. Printf(„Vârsta: %d\n”, persoană. Vârstă)
 fmt. Printf(„E-mail: %s\n”, persoană. E-mail)
}

The principal funcția citește ieșire.yaml dosar cu ioutil pachetelor Citiți fișierul funcţie. Apoi creează o instanță a Persoană struct și parsează datele în struct cu Unmarshal metoda de yaml pachet. The principal funcția imprimă câmpurile din instanța struct; iată rezultatul:

Inserarea datelor într-un fișier YAML

Puteți folosi structurile de date Go pentru a insera date în fișierele YAML. Iată cum puteți insera date într-un fișier YAML cu o instanță a fișierului Persoană structura:

funcprincipal() {
// Creați o instanță a structurii Person cu date eșantion
 persoana := Persoana{
 Nume: „John Doe”,
 Vârstă: 30,
 E-mail: „[email protected]”,
 }
// Serializează structura persoană în format YAML
 date, err := yaml. Mareșal (&persoană)
dacă greș!= zero {
panică(eroare)
 }
// Scrieți datele serializate YAML într-un fișier numit „output.yaml”
 err = os. WriteFile(„output.yaml”, date, 0644)
dacă greș!= zero {
panică(eroare)
 }
 fmt. Println(„Date scrise în output.yaml”)
}

The persoană variabila este o instanță a Persoană tip struct. Folosește Mareșal metoda de yaml pachet pentru a converti structura în YAML. Acesta preia instanța structurii și returnează reprezentarea YAML și o eroare.

Puteți folosi WriteFile funcția de os pachet pentru a scrie datele YAML în fișierul dvs. (în acest caz, ieșire.yaml).

După o operațiune reușită de serializare și scriere a datelor YAML, principal funcția imprimă un mesaj pe consolă.

Puteți distribui și dezactiva YAML în hărți așa cum faceți cu structurile.

Iată un exemplu de repartizare și dezmarșare a datelor YAML cu hărți:

pachet principal
import (
"fmt"
„gopkg.in/yaml.v3”
)
funcprincipal() {
// Date pentru marshaling
 date := Hartă[şir]interfata{}{
"Nume": „John Doe”,
"vârstă": 30,
"e-mail": „[email protected]”,
 }
// Distribuirea datelor în YAML
 yamlData, err := yaml. Mareșal (date)
dacă greș!= zero {
 fmt. Println(„Eroare în timpul marshalingului:”, greseala)
întoarcere
 }
 fmt. Println(„Date grupate YAML:”)
 fmt. Println(şir(yamlData))
// Anularea datelor YAML într-o hartă
var unmarshalledData Hartă[şir]interfata{}
 err = yaml. Unmarshal (yamlData, &unmarshalledData)
dacă greș!= zero {
 fmt. Println(„Eroare la anulare:”, greseala)
întoarcere
 }
 fmt. Println(„\nDate necalificate:”)
 fmt. Println (unmarshalledData)
}

Procesul este același ca pentru tipuri de structuri, cu excepția faptului că utilizați hărți pentru reprezentarea datelor. The Unmarshal și Mareșal metodele funcționează pentru ambele tipuri de date.

Docker Compose utilizează fișiere YAML pentru configurare

Lucrul cu fișierele YAML în Go oferă o abordare puternică și flexibilă pentru gestionarea datelor de configurare.

Un caz de utilizare proeminent pentru fișierele YAML este Docker Compose, unde un fișier YAML servește ca configurație pentru definirea și gestionarea aplicațiilor Docker cu mai multe containere.

Docker Compose valorifică simplitatea și lizibilitatea YAML pentru a defini serviciile, rețelele, volumele și alte componente ale aplicațiilor containerizate pentru a ușura orchestrarea containerelor.