从动态嵌套的已知键中获取值 YAML

Question

我对 Golang 很陌生。 我有一个带有动态密钥的 YAML 文件，但只有一个是已知的，而且它不一定是第一个（配置后）。 在config级别没有其他密钥。

yaml 文件：

config:
    foo:bar: baz
    bar:foo: baz
    abs:getit: myvalue

我想从嵌套键config:abs:getit中检索myvalue 。 这个嵌套的键名永远不会改变，它永远是config:abs:getit 。 所有其他键可以是任何内容，我们不关心，具有不同类型的内容（数组、整数、字符串、数组数组）。

恢复价值的最佳方法是什么？

我使用 yaml package，但我必须修复结构中的每个字段以解组它，但我不知道可以有多少嵌套键，所以我无法编写一个始终有效的结构。

我使用的是 map，但我可以弄清楚我必须使用哪个 map，因为如果我可以在我正在搜索的值之前有一个包含 6 个嵌套键或 3 个包含数组的嵌套键的字段，它将失败。

在动态环境中，我对这些事情感到很迷茫。

理想情况下，我想做一只cat myFile.yaml | yq '.config."abs:getit"' cat myFile.yaml | yq '.config."abs:getit"' ，但在 Golang 中......

有什么想法和最佳实践吗？

Answer 1

你可以做：

func main() {
    var obj struct {
        Config struct {
            AbsGetit string `yaml:"abs:getit"`
        } `yaml:"config"`
    }
    err := yaml.Unmarshal(data, &obj)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%q\n", obj.Config.AbsGetit)
}

https://go.dev/play/p/KJ_lzZxaZBy

Answer 2

感谢您的准确回答。 对不起，问题有误，我为这个错误道歉。

它不是单个流标量 Yaml，而是 map，因为值之前有空格：

config:
    foo:bar: baz
    bar:foo: baz
    abs:getit: myvalue

上面的代码逻辑上会返回一个转换错误，如下所示：

panic: yaml: unmarshal errors:
  line 2: cannot unmarshal !!map into string

我的整个代码在这里。 我读到的文件是一个Pulumi 配置文件 Yaml ，它对于所有项目都是不同的，除了一个公共键（“abs:getit:”），只有值不同。

原始问题文件已被修改。 真的很抱歉...

Answer 3

我想你需要这段代码。 只需将正确的路径放入“myFile.yaml”文件即可。 在 main() function 中，您将看到两个不同的示例，说明如何根据需要使用代码。

getConfVal 在 N 维深度中找到具有任意序列的 YAML 树的节点。 如果该节点不存在，则该值为 nil。

我的文件.yaml

config:
    foo:bar: baz
    bar:foo: baz
    abs:getit: myvalue
    foo:
      bar: "conf-foo-bar"
    bar:
      foo: "conf-bar-foo"
    abs:
      getit: "conf-abs-getit"
one:
  two:
    three:
      four:
        five: 5
        five2: [4, 7]

---

package main

import (
    "fmt"
    "os"

    yaml "gopkg.in/yaml.v3"
)

func main() {
    if err := readTConf("./path/to/myFile.yaml", &cfg); err != nil {
        fmt.Printf("Read YAML Conf: %v\n", err)
        return
    }

    // e.g.
    getConfVal(cfg, []string{"foo:bar"})
    // getConfVal(cfg, []string{"foo", "bar"})
    // getConfVal(cfg, []string{"four", "five"})
    // getConfVal(cfg, []string{"four", "five2"})

    fmt.Printf("\nThis is the result you are looking for. (%v)\n", needleRes)
}

var needleRes interface{}
var cfg map[string]interface{}

func getConfVal(o map[string]interface{}, ns []string) (map[string]interface{}, bool) {
    nsCnt := len(ns)
    for kn, vn := range ns {
        for ko, vo := range o {
            if fmt.Sprintf("%T", vo) == "map[string]interface {}" {
                res, ok := getConfVal(vo.(map[string]interface{}), ns)
                if ok {
                    return res, true
                    break
                }
            }

            if fmt.Sprintf("%T", vo) == "string" {
                if ko == vn {
                    if kn+1 == nsCnt {
                        needleRes = vo
                        return map[string]interface{}{}, true
                    }
                }
            }
        }
    }

    return map[string]interface{}{}, false
}

func readTConf(f string, c *map[string]interface{}) error {
    yamlFile, err := os.ReadFile(f)
    if err != nil {
        return err
    }

    if err := yaml.Unmarshal([]byte(yamlFile), &c); err != nil {
        return err
    }

    return nil
}