How to read a YAML file

Question

I have an issue with reading a YAML file. I think it's something in the file structure but I can't figure out what.

YAML file:

conf:
  hits:5
  time:5000000

code:

type conf struct {
    hits int64 `yaml:"hits"`
    time int64 `yaml:"time"`
}


func (c *conf) getConf() *conf {

    yamlFile, err := ioutil.ReadFile("conf.yaml")
    if err != nil {
        log.Printf("yamlFile.Get err   #%v ", err)
    }
    err = yaml.Unmarshal(yamlFile, c)
    if err != nil {
        log.Fatalf("Unmarshal: %v", err)
    }

    return c
}

Answer 1

your yaml file must be

hits: 5
time: 5000000

your code should look like this:

package main

import (
    "fmt"
    "gopkg.in/yaml.v2"
    "io/ioutil"
    "log"
)

type conf struct {
    Hits int64 `yaml:"hits"`
    Time int64 `yaml:"time"`
}

func (c *conf) getConf() *conf {

    yamlFile, err := ioutil.ReadFile("conf.yaml")
    if err != nil {
        log.Printf("yamlFile.Get err   #%v ", err)
    }
    err = yaml.Unmarshal(yamlFile, c)
    if err != nil {
        log.Fatalf("Unmarshal: %v", err)
    }

    return c
}

func main() {
    var c conf
    c.getConf()

    fmt.Println(c)
}

the main error was capital letter for your struct.

Answer 2

Example

Using an upgraded version 3 of yaml package.

An example conf.yaml file:

conf:
  hits: 5
  time: 5000000
  camelCase: sometext

The main.go file:

package main

import (
    "fmt"
    "io/ioutil"
    "log"

    "gopkg.in/yaml.v3"
)

type myData struct {
    Conf struct {
        Hits      int64
        Time      int64
        CamelCase string `yaml:"camelCase"`
    }
}

func readConf(filename string) (*myData, error) {
    buf, err := ioutil.ReadFile(filename)
    if err != nil {
        return nil, err
    }

    c := &myData{}
    err = yaml.Unmarshal(buf, c)
    if err != nil {
        return nil, fmt.Errorf("in file %q: %w", filename, err)
    }

    return c, err
}

func main() {
    c, err := readConf("conf.yaml")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%#v", c)
}

Running instructions (in case it's the first time you step out of stdlib):

cat conf.yaml
go mod init example.com/whatever
go get gopkg.in/yaml.v3
cat go.sum
go run .

About The yaml:"field"

The tags (like yaml:"field") are optional for all-lowercase yaml key identifiers. For demonstration the above example parses an extra camel case identifier which does require such a tag.

Corner Case: JSON+YAML

Confusingly, the useful lowercasing behavior of yaml package is not seen in the standard json package. Do you have a data structure which is sometimes encoded to JSON and sometimes to YAML? If so, consider specifying both JSON tags and YAML tags on literally every field. Verbose, but reduces mistakes. Example below.

type myData struct {
    Conf conf `yaml:"conf" json:"conf"`
}

type conf struct {
    Hits      int64  `yaml:"hits" json:"hits"`
    Time      int64  `yaml:"time" json:"time"`
    CamelCase string `yaml:"camelCase" json:"camelCase"`
}

Answer 3

package main

import (
    "gopkg.in/yaml.v2"
    "io/ioutil"
    "log"
)

type someConf struct {
    AccessKeyID     string `yaml:"access_key_id"`
   //...
}

func getConf(file string, cnf interface{}) error {
   yamlFile, err := ioutil.ReadFile(file)
   if err == nil {
      err = yaml.Unmarshal(yamlFile, cnf)
   }
   return err
}

func main() {
    cfg := &awsConf{}
    if err := getConf("conf.yml", cfg); err != nil {
        log.Panicln(err)
    }
 }

shortest getConf ever

Answer 4

Here, You can read a YAML file without having a predefined struct. Please substitute "config.yaml" with the desired file name. Add "fmt," "io/ioutil," and "gopkg.in/yaml.v2" to the import list.

    package main

    import (
        "fmt"
        "io/ioutil"

        "gopkg.in/yaml.v2"
    )

    func main() {
        obj := make(map[string]interface{})
    
        yamlFile, err := ioutil.ReadFile("config.yaml")
        if err != nil {
          fmt.Printf("yamlFile.Get err #%v ", err)
        }
        err = yaml.Unmarshal(yamlFile, obj)
        if err != nil {
          fmt.Printf("Unmarshal: %v", err)
        }

        fmt.Println(obj)
    }