Golang validate a yaml structure

Question

Im a newbie in golang. I am trying to validate a yaml structure

prof:
  res:
  - ed:
      app:
        conf:

For that i have read the yaml file using ioutil, then converted it to map string interface. I tried 1) looping over map interface 2) converting it to json string using marshal and then looping but couldn't achieve it.

Any help will be appreciated. Thanks

yfile, err1 := ioutil.ReadFile("C:/Users/212764682/user.yaml")
data := make(map[string]interface{})
err := yaml.Unmarshal(yfile, &data)

Tried iterating like this

for key, value := range data {
        if key == "prof" {
            for key2, value2 := range value.(map[string]interface{}) {
                if key2 == "res" {
                    for key3, value3 := range value2.(map[string]interface{}) {

                        if key3 == "ed" {
                            for key4, value4 := range value3.(map[string]interface{}) {
                                if key4 == "app" {
                                    for key5 := range value4.(map[string]interface{}) {
                                        if key5 == "conf" {
                                            fmt.Println("valid format")

                                        }
                                    }
                                }
                            }
                        }
                    }
                }

            }

        }
    }

You have to first declare the `data` variable before you can unmarshal into that. Check the returned error (`err`) to see if there was any problems with the input yaml. — icza, Apr 26 '22 at 15:07
Does this answer your question? [Parse YAML with structs](https://stackoverflow.com/questions/51775247/parse-yaml-with-structs) — Em Ae, Apr 26 '22 at 15:30

Suyash Medhavi · Answer 1 · 2022-04-28T07:02:55.237

1

You don't have to range over all the keys in a map to find out if it contains a key. See the following example:

if dict2, ok := dict1["foo"]; ok {
    if dict3, ok := dict2["bar"]; ok {
         if dict4, ok := dict3["goo"]; ok {
            // and so on
         } else {
            // key was not found, error
         }
    } else {
        // key was not found, error
    }
} else {
    // key was not found, error
}

edited Apr 28 '22 at 07:02

answered Apr 26 '22 at 20:30

Suyash Medhavi

1,135
6
18

@suyash...its a nested map so thats why i am iterating over all the keys. – sjsri Apr 27 '22 at 06:14
@sjsri updated my answer to explain how you would do that if you have nested maps :) – Suyash Medhavi Apr 28 '22 at 07:03
You might have to do type assertion `.(map[string]interface{})` if needed – Suyash Medhavi Apr 28 '22 at 07:04
might want to invert the checks so you can to it without nesting. Like `if !ok { panic("key doesnt exist") }` – The Fool Apr 29 '22 at 23:00
Although I agree with @TheFool here, to avoid too much nesting. Doing that here would require dict1 dict2 etc to be declared independently – Suyash Medhavi Apr 30 '22 at 09:01

score 1 · Answer 2 · answered Apr 29 '22 at 22:57

Use structs. There are online services to autogenerate the struct from your yaml file. There are many and they are easy to find. Generate a struct and then you can use something like this code:

package main

import (
    "fmt"
    "log"

    "github.com/go-yaml/yaml"
    "io/ioutil"
)

type User struct {
    Prof struct {
        Res []struct {
            Ed struct {
                App struct {
                    Conf struct {
                        Field1 int `yaml:"field1"`
                        Field2 int `yaml:"field2"`
                    } `yaml:"conf"`
                } `yaml:"app"`
            } `yaml:"ed"`
        } `yaml:"res"`
    } `yaml:"prof"`
}

func NewUser(name string) (*User, error) {
    user := new(User)

    file, err := ioutil.ReadFile(name)
    if err != nil {
        return nil, fmt.Errorf("read: %w", err)
    }

    if err := yaml.Unmarshal(file, user); err != nil {
        return nil, fmt.Errorf("unmarshal: %w", err)
    }

    return user, nil
}

func main() {
    user, err := NewUser("user.yaml")
    if err != nil {
        log.Fatalf("user: %s", err)
    }

    fmt.Printf("%+v\n", *user)
}

Best to use a decoder, and call [DisallowUnknownFields](https://pkg.go.dev/encoding/json#Decoder.DisallowUnknownFields). — The Fool, Apr 30 '22 at 13:11
@The Fool, You're right. But there is no `DisallowUnknownFields` function in `yaml` package. We can use [KnownFields](https://pkg.go.dev/gopkg.in/yaml.v3#Decoder.KnownFields) instead. — outdead, Apr 30 '22 at 21:07

Golang validate a yaml structure

2 Answers2