Golang comparing two yaml files and updating them

Question

Im a newbie in golang. I am trying to compare two yaml files and update the 2nd file's value if there is any new value in 1st yaml for that particular key.

So the files are of format: These are sample yaml files. Real yaml files have much more nested complicated maps with different datatypes for each key. 1st yaml:

name: john
city: washington

2nd yaml:

name: peter
city: washington

Final result for 2nd yaml file should be:

name: john
city: washington

Tried creating a map string interface for both yaml files using unmarshal. But having trouble how to compare both maps. Was trying to loop over each key of map and search for that key in 2nd yaml map. If key exists update the value in 2nd yaml map. But i am not able to implement that. Any suggestions/better ideas?

Edit: Updated code

package main

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

    "github.com/imdario/mergo"
    "gopkg.in/yaml.v3"
)

func main() {

    yfile, err := ioutil.ReadFile("C:/Users/212764682/lifecycle/userconfig.yaml")

    if err != nil {

        log.Fatal(err)
    }

    data := make(map[string]interface{})

    err2 := yaml.Unmarshal(yfile, &data)

    if err2 != nil {

        log.Fatal(err2)
    } else {
        
        yfile1, err3 := ioutil.ReadFile("C:/Users/212764682/lifecycle/conf.yaml")
        yfile2, err4 := ioutil.ReadFile("C:/Users/212764682/lifecycle/prof.yaml")

        if err3 != nil && err4 != nil {

            log.Fatal(err3)
            log.Fatal(err4)
        } else {
            dat := make(map[string]interface{})
            dat2 := make(map[string]interface{})
            err5 := yaml.Unmarshal(yfile1, &dat)
            err6 := yaml.Unmarshal(yfile2, &dat2)

            _ = err5
            _ = err6

            for key1, element1 := range data {
                for key2, element2 := range dat {
                    if key1 == key2 {
                        if element1 == element2 {

                        } else {
                            element2 = element1
                        }
                    } else {
                        dat[key1] = data[key1]
                    }
                }

            }
        }

    }

}

So im want to compare each key of data with dat. If that key exists in dat, check for value in data. If value different in dat, update with value of data in dat for that key. Also, if any key of data dosent exist in dat, then append that key in dat. But not able to implement it correctly.

Answer 1

You can try to compare the map and then update it if the key exists. Here's some example using your case.

package main

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

    "gopkg.in/yaml.v3"
)

func main() {
    // read file
    yfile1, err := ioutil.ReadFile("file1.yaml")
    if err != nil {
        log.Fatal(err)
        return
    }

    yfile2, err := ioutil.ReadFile("file2.yaml")
    if err != nil {
        log.Fatal(err)
        return
    }

    // unmarshal ymal
    data1 := make(map[string]interface{})
    if err := yaml.Unmarshal(yfile1, &data1); err != nil {
        log.Fatal(err)
        return
    }

    data2 := make(map[string]interface{})
    if err := yaml.Unmarshal(yfile2, &data2); err != nil {
        log.Fatal(err)
        return
    }

    // from this we can iterate the key in data2 then check whether it exists in data1
    // if so then we can update the value in data2

    // iterate key in data2
    for key2 := range data2 {
        // check whether key2 exists in data1
        if val1, ok := data1[key2]; ok {
            // update the value of key2 in data2
            data2[key2] = val1
        }
    }

    fmt.Printf("data2: %v", data2)
    // output:
    // data2: map[city:washington name:john]

    // you can write the data2 into ymal
    newYfile2, err := yaml.Marshal(&data2)
    if err != nil {
        log.Fatal(err)
        return
    }

    // write to file
    if err = ioutil.WriteFile("new_file2.yaml", newYfile2, 0644); err != nil {
        log.Fatal(err)
        return
    }
}

Inside new_file2.yaml will be like this:

city: washington
name: john

One thing that you need to take a not is that map in Go doesn't maintain the order (AFAIK Go doesn't have built-in OrderedMap type per 7 May 2022) so the order key in the new file will be random

Additional note: for error handling, you better handle it right away (right after you got the error). Here's a good article about it Error handling and Go

Answer 2

There is a maps package, since 1.18 I believe. If you don't care about new keys being added to the destination map you can use its copy function.

func Copy[M ~map[K]V, K comparable, V any](dst, src M)

Copy copies all key/value pairs in src adding them to dst. When a key in src is already present in dst, the value in dst will be overwritten by the value associated with the key in src.

The source code of that function is very simple:

func Copy[M ~map[K]V, K comparable, V any](dst, src M) {
    for k, v := range src {
        dst[k] = v
    }
}

---

You could also do it yourself. The below code is from the helm source code. Unlike the copy function above, it works recursivly:

func mergeMaps(a, b map[string]interface{}) map[string]interface{} {
    out := make(map[string]interface{}, len(a))
    for k, v := range a {
        out[k] = v
    }
    for k, v := range b {
        if v, ok := v.(map[string]interface{}); ok {
            if bv, ok := out[k]; ok {
                if bv, ok := bv.(map[string]interface{}); ok {
                    out[k] = mergeMaps(bv, v)
                    continue
                }
            }
        }
        out[k] = v
    }
    return out
}