Usando YAML, puede escribir programas Go que interactúen con otros usando el formato de datos. Es legible por humanos, por lo que es fácil trabajar con él.

YAML es un popular formato de serialización de datos legibles por humanos. El lenguaje de datos es adecuado para archivos de configuración, intercambio de datos y almacenamiento de datos estructurados.

Muchos proyectos basados ​​en Go, incluidos Gqlgen y herramientas de compilación como Docker-compose, usan archivos YAML para la configuración. Como desarrollador de Go, puede usar herramientas como el paquete yaml para analizar y manipular datos YAML.

Comprender un archivo YAML

Los archivos YAML (YAML Ain't Markup Language) consisten en pares clave-valor, listas y estructuras anidadas. La sintaxis YAML está diseñada para ser visualmente atractiva y fácil de leer. Esto lo convierte en una opción popular para archivos de configuración, con Kubernetes y otros herramientas de orquestación usando YAML.

A diferencia de otros formatos de datos como XML y JSON, YAML se basa en la sangría para representar la jerarquía.

instagram viewer

Así es como puede definir campos básicos con YAML:

nombre:JohnGama
edad:30
correo electrónico:[email protected]

Los dos puntos separan la clave de su valor, que puede ser cualquier tipo de datos YAML válido, incluidas cadenas, números, booleanos o estructuras anidadas.

Las listas le permiten representar una colección de valores. Para definir una lista en YAML, usa un guión seguido de un espacio antes de cada elemento:

frutas:
-manzana
-banana
-naranja

Aquí, frutas es la clave, y las líneas con guión definen una lista de frutas.

YAML también admite estructuras anidadas, lo que le permite representar jerarquías de datos complejas:

persona:
nombre:JohnGama
edad:30
DIRECCIÓN:
calle:123PrincipalCalle
ciudad:Cualquier pueblo
país:EE.UU

El persona key contiene otro conjunto de pares clave-valor, formando una estructura anidada. El DIRECCIÓN key tiene su propio conjunto de pares clave-valor.

Trabajar con YAML en Go

Go no proporciona funcionalidad integrada para archivos YAML, pero hay paquetes de terceros que sí lo hacen.

El Yaml paquete es un paquete popular para trabajar con archivos YAML. Proporciona:

  • Funciones de análisis y serialización.
  • Soporte para etiquetas YAML.
  • Cumplimiento integral de la especificación YAML.
  • Control detallado sobre la clasificación y desclasificación.
  • Manejo de errores.
  • Compatibilidad con múltiples versiones de YAML.

Abra su terminal y ejecute este comando para instalar el paquete YAML para su proyecto:

# instalar la versión 3 del paquete yaml
ve a buscar gopkg.in/yaml.v3

Después de instalar el paquete, puede usar el importar instrucción para importar el paquete a sus archivos Go.

importar"gopkg.in/yaml.v3"

Puede elegir varias versiones de YAML en función de la versión de la especificación de YAML que desee utilizar.

Lectura y análisis de estructuras de datos YAML to Go

Una tarea esencial que querrá llevar a cabo es analizar estructuras de datos YAML to Go. El Yaml El paquete proporciona una API simple y conveniente para hacer esto.

Considere estos datos YAML:

# salida.yaml
persona:
nombre:JohnGama
edad:30
correo electrónico:[email protected]

Puede definir una estructura correspondiente con nombres de campo coincidentes para analizar los datos YAML en una estructura de datos Go con el Yaml paquete.

// La estructura de persona representa la clave de persona en YAML.
tipo Persona estructura {
 Nombre cadena`yaml:"nombre"`
 Edad En t`yaml:"edad"`
 Correo electrónico cadena`yaml:"correo electrónico"`
}

El Yaml Las etiquetas de estructura ayudan a asignar las claves YAML a los campos de estructura durante la operación de análisis.

Así es como puede analizar los datos YAML en una estructura de datos Go:

importar (
"fmt"
"gopkg.in/yaml.v3"
"os"
)
funciónprincipal() {
// lee el archivo output.yaml 
 datos, error: = os. Leer archivo ("salida.yaml")


si error! = nulo {
pánico(errar)
 }

// crea una estructura de persona y deserializa los datos en esa estructura
variable persona persona
si error := yaml. Unmarshal (datos, &persona); error! = nulo {
pánico(errar)
 }

// imprime los campos en la consola
 fmt. imprimirf("Nombre: %s\n", persona. Nombre)
 fmt. imprimirf("Edad: %d\n", persona. Edad)
 fmt. imprimirf("Correo electrónico: %s\n", persona. Correo electrónico)
}

El principal función lee el salida.yaml archivo con el ioutil paquete Leer archivo función. A continuación, crea una instancia de la Persona estructura y analiza los datos en la estructura con el desmantelar metodo de la Yaml paquete. El principal la función imprime los campos de la instancia de estructura; aquí está el resultado:

Insertar datos en un archivo YAML

Puede usar estructuras de datos Go para insertar datos en archivos YAML. Así es como puede insertar datos en un archivo YAML con una instancia del Persona estructura:

funciónprincipal() {
// Crear una instancia de la estructura Person con datos de muestra
 persona := Persona{
 Nombre: "Juan Doe",
 Edad: 30,
 Correo electrónico: "[email protected]",
 }
// Serializa la estructura de la persona en formato YAML
 datos, error: = yaml. Mariscal (y persona)


si error! = nulo {
pánico(errar)
 }


// Escribir los datos YAML serializados en un archivo llamado "output.yaml"
 errar = os. Escribir archivo ("salida.yaml", datos, 0644)


si error! = nulo {
pánico(errar)
 }
 fmt. imprimir("Datos escritos en output.yaml")
}

El persona variable es una instancia de la Persona tipo de estructura. Utilizar el Mariscal metodo de la Yaml paquete para convertir la estructura a YAML. Toma la instancia de la estructura y devuelve la representación YAML y un error.

Puedes usar el Escribir archivo función de la sistema operativo paquete para escribir los datos YAML en su archivo (en este caso, salida.yaml).

Después de una operación exitosa de serialización y escritura de datos YAML, el principal La función imprime un mensaje a la consola.

Puede clasificar y desclasificar YAML en mapas como lo hace con las estructuras.

Este es un ejemplo de cálculo y desclasificación de datos YAML con mapas:

paquete principal
importar (
"fmt"
"gopkg.in/yaml.v3"
)


funciónprincipal() {
// Datos para serializar
 datos := mapa[cadena]interfaz{}{
"nombre": "Juan Doe",
"edad": 30,
"correo electrónico": "[email protected]",
 }


// Ordenar los datos en YAML
 yamlData, error: = yaml. Mariscal (datos)


si error! = nulo {
 fmt. imprimir("Error durante la clasificación:", errar)
devolver
 }


 fmt. imprimir("Datos YAML calculados:")
 fmt. imprimir(cadena(yamlData))


// Desorganizar los datos YAML en un mapa
variable datos no ordenados mapa[cadena]interfaz{}
 err = yaml. Unmarshal (yamlData, &unmarshalledData)


si error! = nulo {
 fmt. imprimir("Error durante la desclasificación:", errar)
devolver
 }
 fmt. imprimir("\nDatos no organizados:")
 fmt. Println (datos no ordenados)
}

El proceso es el mismo que para tipos de estructuras, excepto que está utilizando mapas para la representación de datos. El desmantelar y Mariscal los métodos funcionan para ambos tipos de datos.

Docker Compose usa archivos YAML para la configuración

Trabajar con archivos YAML en Go proporciona un enfoque potente y flexible para administrar los datos de configuración.

Un caso de uso destacado para los archivos YAML es Docker Compose, donde un archivo YAML sirve como configuración para definir y administrar aplicaciones Docker de múltiples contenedores.

Docker Compose aprovecha la simplicidad y la legibilidad de YAML para definir servicios, redes, volúmenes y otros componentes de aplicaciones en contenedores para facilitar la orquestación de contenedores.