如何检查 json 是否与结构/结构字段匹配

Question

是否有一种简单的方法可以检查 myStruct 的每个字段是否使用 json.Unmarshal(jsonData, &myStruct) 进行映射。

我可以想象的唯一方法是将结构的每个字段定义为指针，否则您将始终返回一个初始化的结构。 因此，每个作为对象的 jsonString（即使是空的 {}）都会返回一个初始化的结构，而您无法判断该 json 是否代表您的结构。

我能想到的唯一解决方案是很不舒服：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name *string `json:name`
    Age  *int    `json:age`
    Male *bool   `json:male`
}

func main() {
    var p *Person
    err := json.Unmarshal([]byte("{}"), &p)
    // handle parse error
    if err != nil {
        return
    }

    // handle json did not match error
    if p.Name == nil || p.Age == nil || p.Male == nil {
        return
    }

    // now use the fields with dereferencing and hope you did not forget a nil check
    fmt.Println("Hello " + *p.Name)
}

也许可以使用govalidator 之类的库并使用SetFieldsRequiredByDefault。但是您仍然必须执行验证，并且您仍然需要对整个指针取消引用以进行值检索以及 nil 指针的风险。

我想要的是一个函数，如果字段不匹配，它可以将我未编组的 json 作为结构或错误返回。 golang json 库提供的唯一功能是在未知字段上失败但在缺少字段时不会失败。

有什么想法吗？

Answer 1

另一种方法是实现您自己的json.Unmarshaler，它使用反射（类似于默认的 json unmarshaler）：

有几点需要考虑：

• 如果速度对您来说非常重要，那么您应该编写一个基准来查看额外反射的影响有多大。我怀疑它可以忽略不计，但编写一个小的 go 基准来获得一些数字也无妨。
• stdlib 会将 json 输入中的所有数字解组为浮点数。所以如果你使用反射来设置整数字段，那么你需要自己提供相应的转换（见下例中的TODO）
• json.Decoder.DisallowUnknownFields 函数无法按预期与您的类型一起使用。您需要自己实现（参见下面的示例）
• 如果您决定采用这种方法，您将使您的代码更复杂，从而更难理解和维护。你真的确定你必须知道是否省略了字段吗？也许您可以重构您的字段以充分利用零值？

这里是这种方法的完全可执行测试：

package sandbox

import (
    "encoding/json"
    "errors"
    "reflect"
    "strings"
    "testing"
)

type Person struct {
    Name string
    City string
}

func (p *Person) UnmarshalJSON(data []byte) error {
    var m map[string]interface{}
    err := json.Unmarshal(data, &m)
    if err != nil {
        return err
    }

    v := reflect.ValueOf(p).Elem()
    t := v.Type()

    var missing []string
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        val, ok := m[field.Name]
        delete(m, field.Name)
        if !ok {
            missing = append(missing, field.Name)
            continue
        }

        switch field.Type.Kind() {
        // TODO: if the field is an integer you need to transform the val from float
        default:
            v.Field(i).Set(reflect.ValueOf(val))
        }
    }

    if len(missing) > 0 {
        return errors.New("missing fields: " + strings.Join(missing, ", "))
    }

    if len(m) > 0 {
        extra := make([]string, 0, len(m))
        for field := range m {
            extra = append(extra, field)
        }
        // TODO: consider sorting the output to get deterministic errors:
        // sort.Strings(extra)
        return errors.New("unknown fields: " + strings.Join(extra, ", "))
    }

    return nil
}

func TestJSONDecoder(t *testing.T) {
    cases := map[string]struct {
        in       string
        err      string
        expected Person
    }{
        "Empty object": {
            in:       `{}`,
            err:      "missing fields: Name, City",
            expected: Person{},
        },
        "Name missing": {
            in:       `{"City": "Berlin"}`,
            err:      "missing fields: Name",
            expected: Person{City: "Berlin"},
        },
        "Age missing": {
            in:       `{"Name": "Friedrich"}`,
            err:      "missing fields: City",
            expected: Person{Name: "Friedrich"},
        },
        "Unknown field": {
            in:       `{"Name": "Friedrich", "City": "Berlin", "Test": true}`,
            err:      "unknown fields: Test",
            expected: Person{Name: "Friedrich", City: "Berlin"},
        },
        "OK": {
            in:       `{"Name": "Friedrich", "City": "Berlin"}`,
            expected: Person{Name: "Friedrich", City: "Berlin"},
        },
    }

    for name, c := range cases {
        t.Run(name, func(t *testing.T) {
            var actual Person
            r := strings.NewReader(c.in)
            err := json.NewDecoder(r).Decode(&actual)
            switch {
            case err != nil && c.err == "":
                t.Errorf("Expected no error but go %v", err)
            case err == nil && c.err != "":
                t.Errorf("Did not return expected error %v", c.err)
            case err != nil && err.Error() != c.err:
                t.Errorf("Expected error %q but got %v", c.err, err)
            }

            if !reflect.DeepEqual(c.expected, actual) {
                t.Errorf("\nWant: %+v\nGot:  %+v", c.expected, actual)
            }
        })
    }
}

Answer 2

您可以将p 与空结构进行比较，而不是将每个字段与nil 进行比较。

// handle json did not match error
if p == Person{} {
    return
}

由于Person{} 将使用每个字段的0 值进行初始化，这将导致pointers 的每个属性为nil，strings 将为""，ints 将为@987654330 @，等等。