检查输入是 JSON 还是 YAML 的稳健方法

Question

在下面的代码中，应该接受多行作为 JSON 或 YAML 格式的字符串输入。它首先尝试将输入读取为 JSON，如果 JSON 失败，它会再次尝试将其读取为 YAML，如果两者都失败则返回错误。

现在问题出在 yaml.Unmarshal() 上。我检查了一下，如果输入是 JSON 字符串，它永远不会返回错误。 （正确或不正确）。主要问题 yaml.Unmarshal 永远不会返回错误。

最初，我认为它在 yaml.Unmarshal 实现上出错，但在我看来，它在解析输入时尽了最大努力，并且结构不违反 yaml；它永远不会返回错误。

func SpecsFromString(str string) (*Something, error) {
    r := strings.NewReader(str)
    return ReadTenantsSpec(r)
}

func ReadSpec(b io.Reader) (*Spec, error) {

    var spec Spec

    buffer, err := ioutil.ReadAll(b)
    if err != nil {
        return nil, err
    }

    err = json.Unmarshal(buffer, &spec)
    if err == nil {
        return &spec, nil
    }

    err = yaml.Unmarshal(buffer, &spec)
    if err == nil {
        return &spec, nil
    }

    return nil, &InvalidTenantsSpec{"unknown format"}
}

所以我的问题是，如果输入是 JSON 或 YAML，如何正确执行此测试？ 在我看来，在 JSON unmashler 上做到这一点的唯一方法是区分 两个错误案例。原因是 JSON 通常在结构上更严格。 当输入根本不是 JSON，当输入是 JSON 但 JSON 的结构有错误时。第二种情况将允许我永远不会调用 yaml 解析器 首先。

也许有人想出了一个更巧妙的解决方案？

谢谢。

Answer 1

json.Unmarshal 确实会在无效的 JSON 语法上返回 SyntaxError，并且当语法正确但解组失败时会出现其他不同的错误，因此您可以使用它来区分。

关于 YAML，如果你使用 yaml.v3，你可以编写一个自定义的 unmarshaler 来访问你输入的 Node 表示，并检查根节点是否设置了 Style Flow，这意味着类似于 JSON 的语法.然而，即使使用这种语法，YAML 也更加宽松（例如，字符串不需要被引用，序列中的尾随逗号和映射是允许的），虽然您可以检查包含的标量的引用样式，但可用的信息不足以确保输入是 JSON 可解析的（无法通过此接口检测到尾随逗号）。

所以检查输入是否是语法上有效的 JSON 的正确方法是检查返回的错误 json.Unmarshal。

Answer 2

这就是我在对该问题的评论中引用的内容。这是一个中间件阅读器的简单示例。

1. 此模式可让您避免必须完全解析文本主体，以防文本过大
2. 理想情况下，它对下游操作没有影响，提供透明的 API。

从你的例子中，你会这样称呼：

b = WrapReader(b)
buffer, err := ioutil.ReadAll(b)
if err != nil {return nil, err}
if b.Writable.A > b.Writable.B {
    err = json.Unmarshal(buffer, &spec)
}
if err != nil || b.Writable.A <= b.Writable.B {
    err = yaml.Unmarshal(buffer, &spec)
}

实际上，它不会改变您正在处理的界面，同时获得对进程如何停止的一些控制。有很大的改进空间，但上面的 API 是由下面的代码提供的：

type Line []byte
type Writable struct {
    Line
    A int
    B int
}
type Decision struct{
    io.Reader
    Writable
}
func (d *Decision) Read(b_rx []byte) (int, error) {
    n, err := d.Reader.Read(b_rx)
    if err != nil && err != io.EOF {return n, err}
    for _, b_tx := range b_rx {
        d.Writable.WriteByte(b_tx)
    }
    return n, nil       
}
func (w *Writable) WriteByte (b byte) error {
    if b == '\n' {
        pJSON, pYAML, err := w.Score()
        if err != nil {return err}
        w.A += pJSON
        w.B += pYAML
        w.Line = make(Line, 0)
    } else {
        w.Line = append(w.Line, b)
    }
    return nil
}
func (w *Writable) Score () (int, int, error) {
    //whatever scoring heuristics you can think of.
    return 0,0,nil
}
func WrapReader(b io.Reader) io.Reader {
    return Decision{b,*new(Writable)}
}

Answer 3

几天前我在 bash 脚本中遇到了同样的问题：如何检测文件是否包含 json、yaml 或纯文本？

我的解决方案是：

处理为json

• 可以解析为json而不会出错

处理为text

• 可以解析为yaml，但type只是yaml字符串

处理为yaml

• 可以解析为yaml，但不仅仅是yaml字符串
• 无法解析为 json

Bash 脚本 sn-p

parse_as_json() {
  jq -e '.' > /dev/null 2>&1 < "$1"
}

parse_as_yaml() {
  local FILE=$1
  parse_as_json $FILE && return 1
  parse_as_text $FILE && return 1
  yq -e > /dev/null 2>&1 < $FILE || return 1
}

parse_as_text() {
  [[ $(yq 'type == "string"' 2>&1 < $1) == true ]]
}