json - 在 JSON 字符串 Golang 中检测重复项

Question

我有像

这样的 JSON 字符串

"{\"a\": \"b\", \"a\":true,\"c\":[\"field_3 string 1\",\"field3 string2\"]}"

如何使用Golang检测这个json字符串中的重复属性

Answer 1

使用 json.Decoder遍历 JSON。找到对象后，遍历键和值以检查重复键。

func check(d *json.Decoder, path []string, dup func(path []string) error) error {
    // Get next token from JSON
    t, err := d.Token()
    if err != nil {
        return err
    }

    // Is it a delimiter?
    delim, ok := t.(json.Delim)

    // No, nothing more to check.
    if !ok {
        // scaler type, nothing to do
        return nil
    }

    switch delim {
    case '{':
        keys := make(map[string]bool)
        for d.More() {

            // Get field key.

            t, err := d.Token()
            if err != nil {
                return err
            }
            key := t.(string)

            // Check for duplicates.

            if keys[key] {
                // Duplicate found. Call the application's dup function. The
                // function can record the duplicate or return an error to stop
                // the walk through the document.
                if err := dup(append(path, key)); err != nil {
                    return err
                }
            }
            keys[key] = true

            // Check value.

            if err := check(d, append(path, key), dup); err != nil {
                return err
            }
        }
        // consume trailing }
        if _, err := d.Token(); err != nil {
            return err
        }

    case '[':
        i := 0
        for d.More() {
            if err := check(d, append(path, strconv.Itoa(i)), dup); err != nil {
                return err
            }
            i++
        }
        // consume trailing ]
        if _, err := d.Token(); err != nil {
            return err
        }

    }
    return nil
}

调用方法如下:

func printDup(path []string) error {
    fmt.Printf("Duplicate %s\n", strings.Join(path, "/"))
    return nil
}

...

data := `{"a": "b", "a":true,"c":["field_3 string 1","field3 string2"], "d": {"e": 1, "e": 2}}`
if err := check(json.NewDecoder(strings.NewReader(data)), nil, printDup); err != nil {
    log.Fatal(err)
}

输出是:

Duplicate a
Duplicate d/e

Run it on the Playground

以下是如何在第一个重复键上生成错误:

var ErrDuplicate = errors.New("duplicate")

func dupErr(path []string) error {
    return ErrDuplicate
}

...

data := `{"a": "b", "a":true,"c":["field_3 string 1","field3 string2"], "d": {"e": 1, "e": 2}}`
err := check(json.NewDecoder(strings.NewReader(data)), nil, dupErr)
if err == ErrDuplicate {
    fmt.Println("found a duplicate")
} else if err != nil {
    // some other error
    log.Fatal(err)
}