Comment travailler avec des fichiers YAML dans Go

YAML est un format populaire de sérialisation de données lisible par l'homme. Le langage de données convient aux fichiers de configuration, à l'échange de données et au stockage de données structurées.

De nombreux projets basés sur Go, y compris Gqlgen et des outils de construction comme Docker-compose, utilisent des fichiers YAML pour la configuration. En tant que développeur Go, vous pouvez utiliser des outils tels que le package yaml pour analyser et manipuler les données YAML.

Comprendre un fichier YAML

Les fichiers YAML (YAML Ain't Markup Language) se composent de paires clé-valeur, de listes et de structures imbriquées. La syntaxe YAML est conçue pour être visuellement attrayante et facile à lire. Cela en fait un choix populaire pour les fichiers de configuration, avec Kubernetes et d'autres outils d'orchestration utilisant YAML.

Contrairement à d'autres formats de données comme XML et JSON, YAML s'appuie sur l'indentation pour représenter la hiérarchie.

Voici comment vous pouvez définir des champs de base avec YAML :

nom:JohnBiche
âge:30
e-mail:[email protected]

Deux-points séparent la clé de sa valeur, qui peut être n'importe quel type de données YAML valide, y compris des chaînes, des nombres, des booléens ou des structures imbriquées.

Les listes vous permettent de représenter une collection de valeurs. Pour définir une liste en YAML, utilisez un trait d'union suivi d'un espace avant chaque élément :

des fruits:
-pomme
-banane
-orange

Ici, des fruits est la clé, et les lignes avec trait d'union définissent une liste de fruits.

YAML prend également en charge les structures imbriquées, ce qui vous permet de représenter des hiérarchies de données complexes :

personne:
nom:JohnBiche
âge:30
adresse:
rue:123PrincipalSt
ville:N'importe quelle ville
pays:Etats-Unis

Le personne key contient un autre ensemble de paires clé-valeur, formant une structure imbriquée. Le adresse key a son propre ensemble de paires clé-valeur.

Travailler avec YAML dans Go

Go ne fournit pas de fonctionnalité intégrée pour les fichiers YAML, mais il existe des packages tiers qui le font.

Le yaml emballer est un package populaire pour travailler avec des fichiers YAML. Il offre:

• Fonctionnalités d'analyse et de sérialisation.
• Prise en charge des balises YAML.
• Conformité complète aux spécifications YAML.
• Contrôle précis du regroupement et du déclassement.
• La gestion des erreurs.
• Compatibilité avec plusieurs versions de YAML.

Ouvrez votre terminal et exécutez cette commande pour installer le package YAML pour votre projet :

# installer la version 3 du paquet yaml
allez chercher gopkg.in/yaml.v3

Après avoir installé le package, vous pouvez utiliser le importer pour importer le package dans vos fichiers Go.

importer"gopkg.in/yaml.v3"

Vous pouvez choisir plusieurs versions YAML en fonction de la version de la spécification YAML que vous souhaitez utiliser.

Lecture et analyse des structures de données YAML to Go

Une tâche essentielle que vous voudrez effectuer est l'analyse des structures de données YAML to Go. Le yaml package fournit une API simple et pratique pour ce faire.

Considérez ces données YAML :

# sortie.yaml
personne:
nom:JohnBiche
âge:30
e-mail:[email protected]

Vous pouvez définir une structure correspondante avec des noms de champ correspondants pour analyser les données YAML dans une structure de données Go avec la yaml emballer.

// La structure person représente la clé person dans YAML.
taper Personne structure {
 Nom chaîne`yaml:"nom"`
 Âge entier`yaml:"âge"`
 E-mail chaîne`yaml:"e-mail"`
}

Le yaml Les balises struct permettent de mapper les clés YAML aux champs struct pendant l'opération d'analyse.

Voici comment vous pouvez analyser les données YAML dans une structure de données Go :

importer (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
fonctionprincipal() {
// lit le fichier output.yaml 
 données, erreur := os. LireFichier("sortie.yaml")
si erreur != néant {
panique(se tromper)
 }

// crée une structure de personne et désérialise les données dans cette structure
var personne Personne
si erreur := yaml. Unmarshal (données, &person); erreur != néant {
panique(se tromper)
 }

// imprime les champs sur la console
 fmt. Imprimerf("Nom: %s\n", personne. Nom)
 fmt. Imprimerf("Âge: %d\n", personne. Âge)
 fmt. Imprimerf("E-mail: %s\n", personne. E-mail)
}

Le principal fonction lit le sortie.yaml déposer auprès de la ioutil paquets LireFichier fonction. Il crée ensuite une instance de Personne struct et analyse les données dans le struct avec le Démaréchal méthode de la yaml emballer. Le principal la fonction imprime les champs de l'instance de struct; voici le résultat:

Insertion de données dans un fichier YAML

Vous pouvez utiliser des structures de données Go pour insérer des données dans des fichiers YAML. Voici comment vous pouvez insérer des données dans un fichier YAML avec une instance de Personne structure :

fonctionprincipal() {
// Crée une instance de la structure Person avec des exemples de données
 personne := Personne{
 Nom: "John Doe",
 Âge: 30,
 E-mail: "[email protected]",
 }
// Sérialise la structure person au format YAML
 données, erreur := yaml. Maréchal(&personne)
si erreur != néant {
panique(se tromper)
 }
// Écrit les données YAML sérialisées dans un fichier nommé "output.yaml"
 erreur = os. EcrireFichier("sortie.yaml", données, 0644)
si erreur != néant {
panique(se tromper)
 }
 fmt. Imprimerln("Données écrites dans output.yaml")
}

Le personne variable est une instance de Personne type de structure. Utilisez le Maréchal méthode de la yaml package pour convertir la structure en YAML. Il prend l'instance de la structure et renvoie la représentation YAML et une erreur.

Vous pouvez utiliser le ÉcrireFichier fonction de la os package pour écrire les données YAML dans votre fichier (dans ce cas, sortie.yaml).

Après une opération réussie de sérialisation et d'écriture des données YAML, le principal fonction affiche un message sur la console.

Vous pouvez marshaler et démarshaler YAML dans des cartes comme vous le faites avec des structures.

Voici un exemple de marshaling et de unmarshalling de données YAML avec des cartes :

emballer principal
importer (
"fmt"
"gopkg.in/yaml.v3"
)
fonctionprincipal() {
// Données pour le marshaling
 données := carte[chaîne]interface{}{
"nom": "John Doe",
"âge": 30,
"e-mail": "[email protected]",
 }
// Marshaling des données dans YAML
 yamlData, erreur := yaml. Maréchal (données)
si erreur != néant {
 fmt. Imprimerln("Erreur lors du marshaling :", euh)
retour
 }
 fmt. Imprimerln("Données YAML marshalées :")
 fmt. Imprimerln(chaîne(yamlData))
// Désorganiser les données YAML dans une carte
var unmarshalledData carte[chaîne]interface{}
 erreur = yaml. Démarshaler (yamlData, &unmarshalledData)
si erreur != néant {
 fmt. Imprimerln("Erreur lors du démarshalling :", euh)
retour
 }
 fmt. Imprimerln("\nDonnées non triées :")
 fmt. Println (unmarshalledData)
}

Le processus est le même que pour types de structure, sauf que vous utilisez des cartes pour la représentation des données. Le Démaréchal et Maréchal Les méthodes fonctionnent pour les deux types de données.

Docker Compose utilise des fichiers YAML pour la configuration

L'utilisation de fichiers YAML dans Go offre une approche puissante et flexible pour la gestion des données de configuration.

Un cas d'utilisation important pour les fichiers YAML est Docker Compose, où un fichier YAML sert de configuration pour définir et gérer des applications Docker multi-conteneurs.

Docker Compose tire parti de la simplicité et de la lisibilité de YAML pour définir des services, des réseaux, des volumes et d'autres composants d'applications conteneurisées afin de faciliter l'orchestration des conteneurs.