Go: parsing a YAML file

  • Go
  • Gabriele Romanato

YAML (YAML Ain't Markup Language) format is a human-readable data serialization format commonly used for configurations and structured data. When working with YAML in Go, it's critical to know how to parse a YAML file in order to manipulate the data efficiently within your program. In this article, we will explore how to parse a YAML file using the Go programming language.

To parse a YAML file in Go, we will use an external library called gopkg.in/yaml.v2. To install it, you can run the following command:


go get gopkg.in/yaml.v2

Before we start writing code, create a sample YAML file that we will use for parsing. For example, create a file called config.yaml with the following content:


server:
   port: 8080
   host: localhost
databases:
   name: mydb
   user: myuser

Now that we have our YAML file prepared, we can write the Go code to perform the parsing. Here's an example of how to do it:


package main

import (
    "fmt"
    "os"
    "log"

    "gopkg.in/yaml.v2"
)

type Config struct {
    Server ServerConfig `yaml:"server"`
    Database DatabaseConfig `yaml:"database"`
}

type ServerConfig struct {
    Port int `yaml:"port"`
    Host string `yaml:"host"`
}

type DatabaseConfig struct {
   Name string `yaml:"name"`
   User string `yaml:"user"`
}

func main() {
    // Read the contents of the YAML file
    yamlFile, err := os.ReadFile("config.yaml")
    if err != nil {
        log.Fatalf("Error reading YAML file: %v", err)
    }

    // Declaration of a variable of type Config
    var config Config

    // Parse the YAML file into the Config structure
    err = yaml.Unmarshal(yamlFile, &config)
    if err != nil {
        log.Fatalf("Error parsing YAML file: %v", err)
    }

    // We print the information obtained from parsing
    fmt.Printf("Server Port: %d\n", config.Server.Port)
    fmt.Printf("Server Host: %s\n", config.Server.Host)
    fmt.Printf("Database Name: %s\n", config.Database.Name)
    fmt.Printf("Database User: %s\n", config.Database.User)
}

  1. We import the necessary libraries, including fmt for printing, os for reading the file, log for error handling, and gopkg.in/yaml.v2 for YAML parsing.

  2. We define a Config which corresponds to the structure of our YAML file. We use yaml:"fieldname" labels to associate the fields in the structure with the fields in the YAML file.

  3. In the main:

    • We read the contents of the YAML file using os.ReadFile.
    • Declaring a config variable of type Config, we parse the YAML file using yaml.Unmarshal.
    • We print the information obtained from the parsing.

Now you are ready to parse YAML files with Go and use the data effectively within your program. You can adapt this technique to handle more complex YAML files and custom configurations depending on your needs. Happy programming in Go!

Back to top