高效解析 JSON 数组流：Go 语言中的流式解码实践

聖光之護

发布时间：2026-02-12 10:26:28

120人浏览过

来源于php中文网

原创

高效解析 JSON 数组流：Go 语言中的流式解码实践

本文介绍如何在 go 中高效解析嵌套结构的 json 数组流（非换行分隔格式），避免全量加载与重复扫描，通过轻量级流式词法分析器实现内存友好、高性能的对象逐个解码。

在 Go 开发中，处理 JSON 流数据时，标准库 encoding/json 的 json.Decoder 天然支持换行分隔 JSON（JSON Lines），但对包裹在顶层方括号内的 JSON 数组（如 [{"a":1},{"b":2}]）却无法直接“流式解码单个元素”——因为 Decoder.Decode() 会尝试一次性消费整个数组，导致阻塞或内存暴涨，尤其当数组极大或来自网络/文件流时。

若强行预处理（如去除首尾 []、按 {...} 边界切分字符串），不仅需二次扫描、破坏流式特性，更难以正确处理嵌套对象、引号转义、注释（若存在）等边界情况，可靠性与性能均不可取。

推荐方案：使用专注流式解析的轻量词法扫描器（Lexical Scanner），例如 megajson/scanner。它不构建完整 AST，而是按需产出 Token（如 {、}、"key"、"value"），由开发者基于状态机逻辑组装目标结构，兼顾性能、可控性与低内存占用。

以下是一个生产就绪的示例，支持任意深度嵌套（通过栈管理状态），并严格遵循 JSON 语法：

boardmix博思白板

boardmix博思白板，一个点燃团队协作和激发创意的空间，集aigc，一键PPT，思维导图，笔记文档多种创意表达能力于一体，将团队工作效率提升到新的层次。

下载

package main

import (
    "fmt"
    "strings"

    "github.com/benbjohnson/megajson/scanner"
)

type Message struct {
    Name string `json:"Name"`
    Text string `json:"Text"`
}

func parseJSONArrayStream(r io.Reader) ([]Message, error) {
    s := scanner.NewScanner(r)
    var messages []Message
    var stack []string // 栈记录当前路径（如 ["", "messages", "0", "Name"]）
    var current Message
    var inKey bool
    var lastKey string

    for {
        tok, data, err := s.Scan()
        if err != nil {
            if err == io.EOF {
                break
            }
            return nil, fmt.Errorf("scan error: %w", err)
        }

        switch tok {
        case scanner.TLBRACE:
            // 进入新对象：压栈并重置当前对象（若在数组内）
            stack = append(stack, "object")
            if len(stack) == 2 && stack[0] == "array" { // 顶层数组中的对象
                current = Message{}
            }
        case scanner.TRBRACE:
            // 退出对象：若在顶层数组中，保存当前对象
            if len(stack) >= 2 && stack[0] == "array" && stack[len(stack)-1] == "object" {
                messages = append(messages, current)
            }
            stack = stack[:len(stack)-1]
        case scanner.TLBRACKET:
            stack = append(stack, "array")
        case scanner.TRBRACKET:
            stack = stack[:len(stack)-1]
        case scanner.TSTRING:
            str := string(data)
            if inKey {
                lastKey = str
                inKey = false
            } else {
                // 当前处于 value 位置，根据 lastKey 和栈上下文赋值
                if len(stack) > 0 && stack[len(stack)-1] == "object" {
                    switch lastKey {
                    case "Name":
                        current.Name = str
                    case "Text":
                        current.Text = str
                    }
                }
            }
        case scanner.TCOLON:
            inKey = false
        case scanner.TCOMMA, scanner.TEOF:
            // 忽略分隔符与结束符
        default:
            // 处理数字、布尔、null 等（此处简化，实际需扩展）
            if !inKey && len(stack) > 0 && stack[len(stack)-1] == "object" {
                // 可在此处添加数字/bool 解析逻辑
            }
        }
    }
    return messages, nil
}

func main() {
    data := strings.NewReader(`[
        {"Name": "Ed", "Text": "Knock knock."},
        {"Name": "Sam", "Text": "Who's there?"},
        {"Name": "Ed", "Text": "Go fmt."}
    ]`)

    msgs, err := parseJSONArrayStream(data)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%+v\n", msgs)
}

✅ 关键优势：