8. Resumen¶

Algunos puntos y enlaces a tener en cuenta.

8.1 gopk.in y paquetes go¶

El dominio gopkg.in es un servicio que proporciona una URL amigable para importar versiones específicas de bibliotecas de Go directamente desde GitHub.

¿Cómo funciona?

Formato del import:

import "gopkg.in/<usuario>/<proyecto>.v<versión>"

go Copiar código

import "gopkg.in/yaml.v2

8.2 Paqute go-yaml¶

Permite trabajar con datos en formato YAML. Proporciona funciones para serializar (convertir estructuras de Go a YAML) y deserializar (convertir YAML a estructuras de Go) de manera sencilla y eficiente.

Este paquete está alojado en gopkg.in, una plataforma que facilita la importación de versiones específicas de bibliotecas en Go, y apunta internamente al repositorio original en GitHub.

Características principales
* Lectura y escritura de YAML:
Facilita la conversión entre YAML y estructuras de datos de Go.

• Soporte para tipos de Go:
  Compatible con tipos básicos como mapas, slices, structs, punteros y valores escalares (int, string, bool, etc.).

• Compatibilidad con json:
  La API es similar a la del paquete estándar encoding/json, lo que facilita su uso si ya se tiene experiencia con JSON en Go.

Formato de entrada y salida:

Admite archivos YAML multilineales y complejos. Mantiene una sintaxis limpia y legible.

Funciones principales
1. Unmarshal
Convierte datos YAML en una estructura Go. Es similar a json.Unmarshal.

Firma de la función:

func Unmarshal(in []byte, out interface{}) error

• in []byte: Datos YAML en formato de bytes.
• out interface{}: Una referencia a la variable o estructura donde se almacenarán los datos decodificados.

package main

import (
        "fmt"
        "log"

        "gopkg.in/yaml.v3"
)

// Cadena de texto multilinea que describe el  formato yaml
var data = `
a: Easy!
b:
  c: 2
  d: [3, 4]
`

// Note: struct fields must be public in order for unmarshal to
// correctly populate the data.
type T struct {
        A string
        B struct {
                RenamedC int   `yaml:"c"`
                D        []int `yaml:",flow"`
        }
}

func main() {
        t := T{}

        err := yaml.Unmarshal([]byte(data), &t)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- t:\n%v\n\n", t)

        d, err := yaml.Marshal(&t)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- t dump:\n%s\n\n", string(d))

        m := make(map[interface{}]interface{})

        err = yaml.Unmarshal([]byte(data), &m)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- m:\n%v\n\n", m)

        d, err = yaml.Marshal(&m)
        if err != nil {
                log.Fatalf("error: %v", err)
        }
        fmt.Printf("--- m dump:\n%s\n\n", string(d))
}

La salida de este programa será:

```text --- t: {Easy! {2 [3 4]}}

--- t dump: a: Easy! b: c: 2 d: [3, 4]

--- m: map[a:Easy! b:map[c:2 d:[3 4]]]

--- m dump: a: Easy! b: c: 2 d: - 3 - 4

Descripción de los campos de: 
```go
type T struct {
        A string
        B struct {
                RenamedC int   `yaml:"c"`
                D        []int `yaml:",flow"`
        }
}

• A string:
  Representa la clave a en el YAML.
  El campo es público porque comienza con una letra mayúscula.
• B struct {...}:
  Representa la clave b en el YAML.
  Es un objeto anidado que contiene dos campos:
  • RenamedC int yaml:"c"`:
    Mapea la clave c del YAML al campo RenamedC de la estructura Go. El tag yaml:"c" indica que el nombre en YAML es c, aunque en Go el campo se llame RenamedC.
  • D []int yaml:",flow"`:
    Mapea la clave d del YAML como una lista de enteros.
    El tag yaml:",flow" indica que el formato de salida debe ser en flow style (una lista en línea: [3, 4]).

Puntos clave
* Uso de Tags: * Las etiquetas (tags) como yaml:"c" y yaml:",flow" son metadatos que indican cómo mapear los datos entre el formato YAML y los campos Go. * Campos Públicos: * Para que el método yaml.Unmarshal pueda asignar valores correctamente, los campos de la estructura deben ser públicos (inician con mayúscula). * Mapeo anidado: * La clave b del YAML se convierte en una estructura anidada dentro de T.

8.3 Enlaces¶

• Liberia estandard