Come lavorare con i file YAML in Go

YAML è un popolare formato di serializzazione dei dati leggibile dall'uomo. Il linguaggio dei dati è adatto per i file di configurazione, lo scambio di dati e l'archiviazione strutturata dei dati.

Molti progetti basati su Go, tra cui Gqlgen e strumenti di compilazione come Docker-compose, utilizzano file YAML per la configurazione. In qualità di sviluppatore Go, puoi utilizzare strumenti come il pacchetto yaml per analizzare e manipolare i dati YAML.

Comprensione di un file YAML

I file YAML (YAML Ain't Markup Language) sono costituiti da coppie chiave-valore, elenchi e strutture nidificate. La sintassi YAML è progettata per essere visivamente accattivante e facile da leggere. Questo lo rende una scelta popolare per i file di configurazione, con Kubernetes e altro strumenti di orchestrazione che utilizzano YAML.

A differenza di altri formati di dati come XML e JSON, YAML si basa sul rientro per rappresentare la gerarchia.

Ecco come puoi definire i campi di base con YAML:

nome:JohnDai
età:30
e-mail:[email protected]

I due punti separano la chiave dal suo valore, che può essere qualsiasi tipo di dati YAML valido inclusi stringhe, numeri, valori booleani o strutture nidificate.

Gli elenchi consentono di rappresentare una raccolta di valori. Per definire un elenco in YAML, utilizza un trattino seguito da uno spazio prima di ogni elemento:

frutta:
-mela
-banana
-arancia

Qui, frutta è la chiave e le linee con trattino definiscono un elenco di frutti.

YAML supporta anche strutture nidificate, consentendoti di rappresentare complesse gerarchie di dati:

persona:
nome:JohnDai
età:30
indirizzo:
strada:123PrincipaleS
città:Qualsiasi città
Paese:Stati Uniti d'America

IL persona key contiene un altro insieme di coppie chiave-valore, formando una struttura nidificata. IL indirizzo key ha il proprio set di coppie chiave-valore.

Lavorare con YAML in Go

Go non fornisce funzionalità integrate per i file YAML, ma ci sono pacchetti di terze parti che lo fanno.

IL yaml pacchetto è un pacchetto popolare per lavorare con i file YAML. Fornisce:

• Funzionalità di analisi e serializzazione.
• Supporto per tag YAML.
• Conformità completa alle specifiche YAML.
• Controllo granulare su marshalling e unmarshalling.
• Gestione degli errori.
• Compatibilità con più versioni YAML.

Apri il tuo terminale ed esegui questo comando per installare il pacchetto YAML per il tuo progetto:

# installa la versione 3 del pacchetto yaml
vai a prendere gopkg.in/yaml.v3

Dopo aver installato il pacchetto, è possibile utilizzare il file importare istruzione per importare il pacchetto nei tuoi file Go.

importare"gopkg.in/yaml.v3"

Puoi scegliere più versioni YAML in base alla versione della specifica YAML che desideri utilizzare.

Lettura e analisi di strutture dati YAML to Go

Un'attività essenziale che vorrai svolgere è l'analisi delle strutture di dati YAML to Go. IL yaml Il pacchetto fornisce un'API semplice e conveniente per farlo.

Considera questi dati YAML:

# output.yaml
persona:
nome:JohnDai
età:30
e-mail:[email protected]

Puoi definire una struttura corrispondente con nomi di campo corrispondenti per analizzare i dati YAML in una struttura di dati Go con il yaml pacchetto.

// Person struct rappresenta la chiave person in YAML.
tipo Persona struct {
 Nome corda`yaml:"nome"`
 Età int`yaml:"età"`
 E-mail corda`yaml:"e-mail"`
}

IL yaml I tag struct aiutano a mappare le chiavi YAML ai campi struct durante l'operazione di analisi.

Ecco come puoi analizzare i dati YAML in una struttura dati Go:

importare (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funzprincipale() {
// legge il file output.yaml 
 data, err := os. LeggiFile("uscita.yaml")
Se errare!= zero {
panico(errare)
 }

// crea una struttura person e deserializza i dati in quella struttura
var persona Persona
Se err := yaml. Unmarshal (dati, &persona); errare!= zero {
panico(errare)
 }

// stampa i campi sulla console
 fmt. Stampaf("Nome: %s\n", persona. Nome)
 fmt. Stampaf("Età: %d\n", persona. Età)
 fmt. Stampaf("Email: %s\n", persona. E-mail)
}

IL principale funzione legge il output.yaml file con il ioutil Pacchetti LeggiFile funzione. Quindi crea un'istanza di Persona struct e analizza i dati nella struttura con il Non maresciallo metodo del yaml pacchetto. IL principale function stampa i campi dall'istanza struct; ecco il risultato:

Inserimento di dati in un file YAML

Puoi utilizzare le strutture dati Go per inserire dati nei file YAML. Ecco come puoi inserire dati in un file YAML con un'istanza di Persona struttura:

funzprincipale() {
// Crea un'istanza della struttura Person con dati di esempio
 persona := Persona{
 Nome: "Giovanni Rossi",
 Età: 30,
 E-mail: "[email protected]",
 }
// Serializza la struttura person in formato YAML
 data, err := yaml. Maresciallo (&persona)
Se errare!= zero {
panico(errare)
 }
// Scrive i dati YAML serializzati in un file chiamato "output.yaml"
 err = os. ScriviFile("uscita.yaml", dati, 0644)
Se errare!= zero {
panico(errare)
 }
 fmt. Stampaln("Dati scritti in output.yaml")
}

IL persona variabile è un'istanza di Persona tipo struct. Usa il Maresciallo metodo del yaml pacchetto per convertire la struttura in YAML. Accetta l'istanza della struttura e restituisce la rappresentazione YAML e un errore.

Puoi usare il ScriviFile funzione del os package per scrivere i dati YAML nel tuo file (in questo caso, output.yaml).

Dopo una corretta serializzazione dei dati YAML e un'operazione di scrittura, il file principale la funzione stampa un messaggio alla console.

Puoi eseguire il marshalling e unmarshalling di YAML nelle mappe come fai con le struct.

Ecco un esempio di marshalling e unmarshalling dei dati YAML con le mappe:

pacchetto principale
importare (
"fmt"
"gopkg.in/yaml.v3"
)
funzprincipale() {
// Dati per il marshalling
 dati := carta geografica[corda]interfaccia{}{
"nome": "Giovanni Rossi",
"età": 30,
"e-mail": "[email protected]",
 }
// Marshaling dei dati in YAML
 yamlData, err := yaml. Maresciallo (dati)
Se errare!= zero {
 fmt. Stampaln("Errore durante il marshalling:", ehm)
ritorno
 }
 fmt. Stampaln("Dati YAML sottoposti a marshalling:")
 fmt. Stampaln(corda(yamlData))
// Unmarshalling dei dati YAML in una mappa
var unmarshallingData carta geografica[corda]interfaccia{}
 err = yaml. Unmarshal (yamlData, &unmarshalledData)
Se errare!= zero {
 fmt. Stampaln("Errore durante l'annullamento del marshalling:", ehm)
ritorno
 }
 fmt. Stampaln("\nDati non marshalling:")
 fmt. Println (dati senza marshalling)
}

Il processo è lo stesso di tipi di struttura, tranne per il fatto che stai utilizzando le mappe per la rappresentazione dei dati. IL Non maresciallo E Maresciallo metodi funzionano per entrambi i tipi di dati.

Docker Compose utilizza i file YAML per la configurazione

Lavorare con i file YAML in Go offre un approccio potente e flessibile per la gestione dei dati di configurazione.

Un caso d'uso importante per i file YAML è Docker Compose, in cui un file YAML funge da configurazione per la definizione e la gestione di applicazioni Docker multi-contenitore.

Docker Compose sfrutta la semplicità e la leggibilità di YAML per definire servizi, reti, volumi e altri componenti delle applicazioni containerizzate per semplificare l'orchestrazione dei container.