用一些已知和一些未知的字段名解组JSON

Question

我有以下 JSON

{"a":1, "b":2, "?":1, "??":1}

我知道它有“a”和“b”字段，但我不知道其他字段的名称。所以我想以以下类型散集它：

type Foo struct {
  // Known fields
  A int `json:"a"`
  B int `json:"b"`
  // Unknown fields
  X map[string]interface{} `json:???` // Rest of the fields should go here.
}

我该怎么做？

Answer 1

最简单的方法是使用这样的界面：

var f interface{}
s := `{"a":1, "b":2, "x":1, "y":1}`

if err := json.Unmarshal([]byte(s), &f); err != nil {
    panic(err)
}

去游乐场示例

Answer 2

这并不好，但你可以通过实现 Unmarshaler 来实现它：

type _Foo Foo

func (f *Foo) UnmarshalJSON(bs []byte) (err error) {
    foo := _Foo{}

    if err = json.Unmarshal(bs, &foo); err == nil {
        *f = Foo(foo)
    }

    m := make(map[string]interface{})

    if err = json.Unmarshal(bs, &m); err == nil {
        delete(m, "a")
        delete(m, "b")
        f.X = m
    }

    return err
}

_Foo类型对于避免解码时的递归是必要的。

Answer 3

一种选择是取消封送两次：一次解组为 Foo 类型的值，一次解组为 map[string]interface{} 类型的值，并删除键“a”和“b”：

type Foo struct {
    A int                    `json:"a"`
    B int                    `json:"b"`
    X map[string]interface{} `json:"-"` // Rest of the fields should go here.
}

func main() {
    s := `{"a":1, "b":2, "x":1, "y":1}`
    f := Foo{}
    if err := json.Unmarshal([]byte(s), &f); err != nil {
        panic(err)
    }

    if err := json.Unmarshal([]byte(s), &f.X); err != nil {
        panic(err)
    }
    delete(f.X, "a")
    delete(f.X, "b")

    fmt.Printf("%+v", f)
}

输出（在Go Playground上尝试）：

{A:1 B:2 X:map[x:1 y:1]}

另一种选择是散集一次到map[string]接口{}并手动处理Fo. A和Fo. B字段：

type Foo struct {
    A int                    `json:"a"`
    B int                    `json:"b"`
    X map[string]interface{} `json:"-"` // Rest of the fields should go here.
}

func main() {
    s := `{"a":1, "b":2, "x":1, "y":1}`
    f := Foo{}
    if err := json.Unmarshal([]byte(s), &f.X); err != nil {
        panic(err)
    }
    if n, ok := f.X["a"].(float64); ok {
        f.A = int(n)
    }
    if n, ok := f.X["b"].(float64); ok {
        f.B = int(n)
    }
    delete(f.X, "a")
    delete(f.X, "b")

    fmt.Printf("%+v", f)
}

输出相同（Go Playground）：

{A:1 B:2 X:map[x:1 y:1]}