将 yaml 字段动态解析为 Go 中的一组有限结构之一

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《将 yaml 字段动态解析为 Go 中的一组有限结构之一》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

我有一个 yaml 文件，其中一个字段可以由一种可能的结构类型表示。为了简化代码和 yaml 文件，假设我有这些 yaml 文件：

kind: "foo"
spec:
  fooval: 4

kind: "bar"
spec:
  barval: 5

这些用于解析的结构：

    type spec struct {
        kind string      `yaml:"kind"`
        spec interface{} `yaml:"spec"`
    }
    type foo struct {
        fooval int `yaml:"fooval"`
    }
    type bar struct {
        barval int `yaml:"barval"`
    }

我知道我可以使用 map[string]interface{} 作为 spec 字段的类型。但真实的例子更复杂，涉及更多可能的结构类型，不仅仅是foo和bar，这就是为什么我不喜欢将spec解析到字段中。

我找到了解决方法：将 yaml 解组为中间结构，然后检查 kind 字段，并将 map[string]interface{} 字段编组回 yaml，然后将其解组为具体类型：

    var spec Spec
    if err := yaml.Unmarshal([]byte(src), &spec); err != nil {
        panic(err)
    }
    tmp, _ := yaml.Marshal(spec.Spec)
    if spec.Kind == "foo" {
        var foo Foo
        yaml.Unmarshal(tmp, &foo)
        fmt.Printf("foo value is %d\n", foo.FooVal)
    }
    if spec.Kind == "bar" {
        tmp, _ := yaml.Marshal(spec.Spec)
        var bar Bar
        yaml.Unmarshal(tmp, &bar)
        fmt.Printf("bar value is %d\n", bar.BarVal)
    }

但它需要额外的步骤并消耗更多的内存（真实的 yaml 文件可能比示例中的更大）。是否存在一些更优雅的方法将 yaml 动态解组为一组有限的结构？

更新：我正在使用 github.com/go-yaml/yaml v2.1.0 yaml 解析器。

解决方案

要与 yaml.v2 一起使用，您可以执行以下操作：

type yamlnode struct {
    unmarshal func(interface{}) error
}

func (n *yamlnode) unmarshalyaml(unmarshal func(interface{}) error) error {
    n.unmarshal = unmarshal
    return nil
}

type spec struct {
    kind string      `yaml:"kind"`
    spec interface{} `yaml:"-"`
}

func (s *spec) unmarshalyaml(unmarshal func(interface{}) error) error {
    type s spec
    type t struct {
        s    `yaml:",inline"`
        spec yamlnode `yaml:"spec"`
    }

    obj := &t{}
    if err := unmarshal(obj); err != nil {
        return err
    }
    *s = spec(obj.s)

    switch s.kind {
    case "foo":
        s.spec = new(foo)
    case "bar":
        s.spec = new(bar)
    default:
        panic("kind unknown")
    }
    return obj.spec.unmarshal(s.spec)
}

https://play.golang.org/p/Ov0cOaedb-x

要与 yaml.v3 一起使用，您可以执行以下操作：

type spec struct {
    kind string      `yaml:"kind"`
    spec interface{} `yaml:"-"`
}

func (s *spec) unmarshalyaml(n *yaml.node) error {
    type s spec
    type t struct {
        *s   `yaml:",inline"`
        spec yaml.node `yaml:"spec"`
    }

    obj := &t{s: (*s)(s)}
    if err := n.decode(obj); err != nil {
        return err
    }

    switch s.kind {
    case "foo":
        s.spec = new(foo)
    case "bar":
        s.spec = new(bar)
    default:
        panic("kind unknown")
    }
    return obj.spec.decode(s.spec)
}

https://play.golang.org/p/ryEuHyU-M2Z

您可以通过实现自定义 unmarshalyaml 函数来实现此目的。但是，使用 v2 版本的 api，您基本上会做与现在相同的事情，只是封装得更好一些。

但是，如果您改用 v3 api，您将获得更好的 unmarshalyaml，它实际上可以让您在将解析的 yaml 节点处理为原生 go 类型之前对其进行处理。看起来是这样的：

package main

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

type spec struct {
    kind string      `yaml:"kind"`
    spec interface{} `yaml:"spec"`
}
type foo struct {
    fooval int `yaml:"fooval"`
}
type bar struct {
    barval int `yaml:"barval"`
}

func (s *spec) unmarshalyaml(value *yaml.node) error {
    s.kind = ""
    for i := 0; i < len(value.content)/2; i += 2 {
        if value.content[i].kind == yaml.scalarnode &&
            value.content[i].value == "kind" {
            if value.content[i+1].kind != yaml.scalarnode {
                return errors.new("kind is not a scalar")
            }
            s.kind = value.content[i+1].value
            break
        }
    }
    if s.kind == "" {
        return errors.new("missing field `kind`")
    }
    switch s.kind {
    case "foo":
        var foo foo
        if err := value.decode(&foo); err != nil {
            return err
        }
        s.spec = foo
    case "bar":
        var bar bar
        if err := value.decode(&bar); err != nil {
            return err
        }
        s.spec = bar
    default:
        return errors.new("unknown kind: " + s.kind)
    }
    return nil
}

var input1 = []byte(`
kind: "foo"
spec:
  fooval: 4
`)

var input2 = []byte(`
kind: "bar"
spec:
  barval: 5
`)

func main() {
    var s1, s2 spec
    if err := yaml.unmarshal(input1, &s1); err != nil {
        panic(err)
    }
    fmt.printf("type of spec from input1: %t\n", s1.spec)
    if err := yaml.unmarshal(input2, &s2); err != nil {
        panic(err)
    }
    fmt.printf("type of spec from input2: %t\n", s2.spec)
}

我建议研究一下使用 yaml 标签而不是当前结构在 yaml 中对此进行建模的可能性；标签正是为此目的而设计的。而不是当前的 yaml

kind: "foo"
spec:
  fooval: 4

你可以写

--- !foo
fooVal: 4

现在您不再需要 kind 和 spec 的描述结构。加载它看起来有点不同，因为您需要一个可以定义 unmarshalyaml 的包装根类型，但如果这只是较大结构的一部分，则可能是可行的。您可以在 yaml.node 的 tag 字段中访问标签 !foo。

理论要掌握，实操不能落！以上关于《将 yaml 字段动态解析为 Go 中的一组有限结构之一》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！