合并两个YAML文件：使用动态和/或递归方法

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《合并两个YAML文件：使用动态和/或递归方法》，涉及到，有需要的可以收藏一下

此问题已针对合并两个 yaml 的顶级 map[string]interface{} 值得到解答，但是否可以合并两个 yaml 文件

a.没有定义结构和

b.具有多个未知级别的嵌套？

我尝试解组到同一个空白界面，但覆盖 yaml 完全被擦除 基础 yaml。

// using "gopkg.in/yaml.v2"

var i interface{}

d, _ := ioutil.ReadFile("base.yaml")
yaml.Unmarshal(d, &i)

d2, _ = ioutil.ReadFile("override.yaml")
yaml.Unmarshal(d2, &i)

m, _ := yaml.Marshal(i)
ioutil.WriteFile("new.yaml", m, xxxx)

新写入的文件就是 override.yaml。

如何合并两个具有未知深度的嵌套值的 yaml 文件，而不定义结构来封装它们的主体？我是否需要执行自定义递归操作，或者可以使用已构建的工具来处理此操作吗？

解决方案

您不应完全解组 yaml 文件，而应仅组合它们。在 yaml 术语中，这意味着构建一个节点图，而不对其进行进一步处理（通常，节点图随后将被处理为本机类型）。 go-yaml 为此提供了 yaml.node 类型，但您需要不稳定的 v3 版本。

当两个文件都可用作节点后，您只需对它们实现合并操作，例如

package main

import (
    "errors"
    "gopkg.in/yaml.v3"
    "os"
)

var input1 = []byte(`
a: b
c:
  d: e
`)

var input2 = []byte(`
c:
  f: g
h: i
`)

func nodesequal(l, r *yaml.node) bool {
    if l.kind == yaml.scalarnode && r.kind == yaml.scalarnode {
        return l.value == r.value
    }
    panic("equals on non-scalars not implemented!")
}

func recursivemerge(from, into *yaml.node) error {
    if from.kind != into.kind {
        return errors.new("cannot merge nodes of different kinds")
    }
    switch from.kind {
    case yaml.mappingnode:
        for i := 0; i < len(from.content); i += 2 {
            found := false
            for j := 0; j < len(into.content); j += 2 {
                if nodesequal(from.content[i], into.content[j]) {
                    found = true
                    if err := recursivemerge(from.content[i+1], into.content[j+1]); err != nil {
                        return errors.new("at key "+from.content[i].value+": "+err.error())
                    }
                    break
                }
            }
            if !found {
                into.content = append(into.content, from.content[i:i+2]...)
            }
        }
    case yaml.sequencenode:
        into.content = append(into.content, from.content...)
    case yaml.documentnode:
        recursivemerge(from.content[0], into.content[0])
    default:
        return errors.new("can only merge mapping and sequence nodes")
    }
    return nil
}


func main() {
    var v1, v2 yaml.node
    yaml.unmarshal(input1, &v1)
    yaml.unmarshal(input2, &v2)
    if err := recursivemerge(&v1, &v2); err != nil {
        panic(err)
    }
    e := yaml.newencoder(os.stdout)
    e.encode(&v2)
    e.close()
}

此代码输出

c:
    f: g
    d: e
h: i
a: b

如您所见，它合并​​了顶层和 c: 内部的值。理论上，您还需要在序列和映射节点上实现 nodesequal，因为这些节点也可以是键，但此功能很少使用，因此如果不需要，可以将其省略。此代码还通过简单地将序列连接成单个序列来合并序列，这可能是也可能不是您想要的。如果您还想正确处理别名节点，则需要更多代码。

终于介绍完啦！小伙伴们，这篇关于《合并两个YAML文件：使用动态和/或递归方法》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！