php小编西瓜在这篇文章中将要介绍如何合并来自 YAML 文件的两个映射层次结构，并保留所有键。这个过程非常简单，只需要使用适当的函数和方法即可完成。通过合并两个映射层次结构，我们可以将它们的键和值组合在一起，以创建一个更大、更全面的映射层次结构。无论您是在处理配置文件还是在进行数据处理，合并映射层次结构都是一个非常有用的技巧。接下来，我们将一步步为您介绍这个过程，让您轻松掌握这个技巧。

问题内容

我正在研究涉及 yaml 文件中的嵌套键的解决方案。软件将读取参数中传递的文件并按照更新/添加密钥的顺序加载它们。

我有 2 个 yaml 文件，我想合并它们而不丢失任何密钥。我想堆叠所有配置文件以生成单个地图而不删除任何键。

所以我有 yaml 1

env: test1
template:
  app:
    database: 
      name: oracle

yaml2

env: test2
template:
  app:
    database: 
      version : 12

我想要的结果是（顺序是yaml1 - yaml2）

env: test2
template:
  app:
    database: 
      name: oracle
      version: 12

我尝试使用地图进行复制，但由于键具有相同的名称，所以我最终得到了

env: test2
template:
    app:
        database:
            version: 12

我正在使用

用于读取 yaml 的 gopkg.in/yaml.v3 为我提供了 map[string] 接口{}

和地图使用复制

package main

import (
    "fmt"
    "log"
    "maps"
    "os"
    "path/filepath"

    "gopkg.in/yaml.v3"
)

type configuration struct {
    c  m
    fl []string
}

type m = map[string]interface{}

func (c *configuration) Update(nc m) {
    if c.c == nil {
        c.c = nc
    } else {
        maps.Copy(c.c, nc)
    }
}

func (c configuration) Print() {
    d, err := yaml.Marshal(&c.c)
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    fmt.Printf("---:n%snn", string(d))
}

func (c configuration) ParseDir(path string) {

}

func (c *configuration) LoadFromFile(filename string) {

    // YAML string stored in a variable
    yf, yfErr := os.ReadFile(filename)

    if yfErr != nil {
        log.Fatal("Error reading the file ", yfErr)
    }
    // Map to store the parsed YAML data
    var data m

    // Unmarshal the YAML string into the data map
    err := yaml.Unmarshal(yf, &data)
    if err != nil {
        log.Fatal(err)
    }
    c.Update(data)
}

func listFiles(path string) []string {
    var returnLf []string
    err := filepath.Walk(path,
        func(path string, info os.FileInfo, err error) error {
            if err != nil {
                return err
            }
            if info.Mode().IsRegular() {
                returnLf = append(returnLf, path)
            }
            return nil
        })
    if err != nil {
        log.Println(err)
    }
    return returnLf

}

解决方法

假设您想要合并两个 YAML 文档中以“模板”为键的 YAML 映射，一个相当简单的实现将如下所示：

package main

import (
    "fmt"

    "gopkg.in/yaml.v3"
)

const data1 = `---
env: test1
template:
  app:
    database: 
      name: oracle
      foo: whatever
`

const data2 = `---
env: test2
template:
  app:
    some_stuff: [1, 2, 3, 4]
    database: 
      version : 12
      foo: 42
`

type T struct {
    Env  string         `yaml:"env"`
    Tmpl map[string]any `yaml:"template"`
}

func mergeMapsRecursively(dst, src map[string]any) map[string]any {
    res := make(map[string]any)

    for dstKey, dstVal := range dst {
        srcVal, exists := src[dstKey]
        if !exists {
            res[dstKey] = dstVal
            continue
        }

        dstValMap, dstValIsMap := dstVal.(map[string]any)
        srcValMap, srcValIsMap := srcVal.(map[string]any)
        if dstValIsMap && srcValIsMap {
            res[dstKey] = mergeMapsRecursively(dstValMap, srcValMap)
        } else {
            res[dstKey] = srcVal
        }
    }

    for srcKey, srcVal := range src {
        if _, exists := dst[srcKey]; !exists {
            res[srcKey] = srcVal
        }
    }

    return res
}

func main() {
    var a, b T

    if err := yaml.Unmarshal([]byte(data1), &a); err != nil {
        panic(err)
    }

    if err := yaml.Unmarshal([]byte(data2), &b); err != nil {
        panic(err)
    }

    fmt.Printf("%#vn%#vn%#vn", a.Tmpl, b.Tmpl, mergeMapsRecursively(a.Tmpl, b.Tmpl))
}

Playground 链接。

mergeMapsRecursively 函数递归地合并两个映射中存在的字段（如果它们都是映射），或者将 dst 中的值替换为 src 中的值，否则 — 就像 maps.Copy 所做的那样。

如果这不完全是您所要求的，我希望我的示例无论如何都能让您走上正轨。