在 Go 中如何以流的方式读取 JSON 对象，而不进行解码

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《在 Go 中如何以流的方式读取 JSON 对象，而不进行解码》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下，希望所有认真读完的童鞋们，都有实质性的提高。

我正在读取 json 以响应 http 端点，并希望提取嵌套在其中的对象数组的内容。响应可能很大，因此我尝试使用流式传输方法，而不仅仅是 json.unmarshal'ing 整个内容。 json 看起来像这样：

{
"useless_thing_1": { /* etc */ },
"useless_thing_2": { /* etc */ },
"the_things_i_want": [
  { /* complex object i want to json.unmarshal #1 */ },
  { /* complex object i want to json.unmarshal #2 */ },
  { /* complex object i want to json.unmarshal #3 */ },
  /* could be many thousands of these */
],
"useless_thing_3": { /* etc */ },
}

go 提供的 json 库有 json.unmarshal，它适用于完整的 json 对象。它还具有 json.decoder ，可以解组完整对象或提供单独的令牌。我可以使用此标记生成器仔细检查并提取内容，但这样做的逻辑有些复杂，在将其读取为标记后，我无法轻松地在对象上使用 json.unmarshal 。

json.decoder 被缓冲，这使得读取一个对象（即 { /* 我想要 json.unmarshal #1 */ } 的复杂对象）变得困难，然后自己使用 、 并创建一个新的json.decoder - 因为它会尝试消耗逗号本身。这是我尝试过的方法，但尚未成功。

我正在寻找更好的解决方案来解决这个问题。这是我尝试手动使用逗号时损坏的代码：

// code here that naively looks for `"the_things_i_want": [` and
// puts the next bytes after that in `buffer`

// this is the rest of the stream starting from `{ /* complex object I want to json.Unmarshal #1 */ },`
in := io.MultiReader(buffer, res.Body) 

dec := json.NewDecoder(in)

for {

    var p MyComplexThing
    err := dec.Decode(&p)
    if err != nil {
        panic(err)
    }

    // steal the comma from in directly - this does not work because the decoder buffer's its input
    var b1 [1]byte
    _, err = io.ReadAtLeast(in, b1[:], 1) // returns random data from later in the stream
    if err != nil {
        panic(err)
    }
    switch b1[0] {
    case ',':
        // skip over it
    case ']':
        break // we're done
    default:
        panic(fmt.Errorf("Unexpected result from read %#v", b1))
    }
}

解决方案

使用 Decoder.Token 和 Decoder.More 将 json 文档解码为流。

使用 Decoder.Token 浏览文档，找到感兴趣的 json 值。调用 Decoder.Decode 将 json 值解组为 go 值。根据需要重复以吸收所有感兴趣的值。

下面是一些带有注释的代码，解释了它的工作原理：

func decode(r io.Reader) error {
    d := json.NewDecoder(r)

    // We expect that the JSON document is an object.
    if err := expect(d, json.Delim('{')); err != nil {
        return err
    }

    // While there are fields in the object...
    for d.More() {

        // Get field name
        t, err := d.Token()
        if err != nil {
            return err
        }

        // Skip value if not the field that we are looking for.
        if t != "the_things_i_want" {
            if err := skip(d); err != nil {
                return err
            }
            continue
        }

        // We expect JSON array value for the field.
        if err := expect(d, json.Delim('[')); err != nil {
            return err
        }

        // While there are more JSON array elements...
        for d.More() {

            // Unmarshal and process the array element.

            var m map[string]interface{}
            if err := d.Decode(&m); err != nil {
                return err
            }
            fmt.Printf("found %v\n", m)
        }

        // We are done decoding the array.
        return nil

    }
    return errors.New("things I want not found")
}

// skip skips the next value in the JSON document.
func skip(d *json.Decoder) error {
    n := 0
    for {
        t, err := d.Token()
        if err != nil {
            return err
        }
        switch t {
        case json.Delim('['), json.Delim('{'):
            n++
        case json.Delim(']'), json.Delim('}'):
            n--
        }
        if n == 0 {
            return nil
        }
    }
}

// expect returns an error if the next token in the document is not expectedT.
func expect(d *json.Decoder, expectedT interface{}) error {
    t, err := d.Token()
    if err != nil {
        return err
    }
    if t != expectedT {
        return fmt.Errorf("got token %v, want token %v", t, expectedT)
    }
    return nil
}

Run it on the playground。

理论要掌握，实操不能落！以上关于《在 Go 中如何以流的方式读取 JSON 对象，而不进行解码》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！