如何在 JS 中解析流上的第一个 JSON 对象

Question

我有一个 JSON 对象流，例如基于 TCP 或 WebSockets 的 JSON-RPC。没有长度前缀或分隔符，因为 JSON 是自定界的。所以，当我从流中读取时，我可能会得到这样的结果：

{"id":1,"result":{"answer":23},"error":null}
{"id":2,"result":{"answer":42},"error":null}
{"id":3,"result":{"answ

我需要一一解析每个 JSON 对象。我不能用 JSON.parse 做到这一点，因为它只会在最后抛出无关数据的语法错误。

当然，对于那个例子，我可以逐行进行，但我不能依赖看起来像这样的空白； JSON-RPC 可以很容易地看起来像这样：

{
  "id": 1, 
  "result": {
    "answer": 23
  },
  "error":null
} 

或者这个：

{"id":1,"result":{"answer":23},"error":null}{"id":2,"result":{"answer":42},"error":null}

对于大多数其他语言的解析器，显而易见的答案是这样的（以 Python 为例）：

buf = ''
decoder = json.JSONDecoder()
def onReadReady(sock):
  buf += sock.read()
  obj, index = decoder.raw_decode(buf)
  buf = buf[index:]
  if obj:
    dispatch(obj)

但是我在 JS 中找不到类似的东西。我查看了我能找到的每个 JS 解析器，它们都等效于 JSON.parse。

我尝试查看各种 JSON-RPC 框架以了解它们如何处理此问题，但它们没有。他们中的许多人假设 recv 将始终只返回一个发送（这适用于通过 HTTP 的 JSON-RPC，但不适用于通过 TCP 或 WebSockets ——当然，它可能在本地测试中工作）。其他人实际上并不处理 JSON-RPC，因为它们添加了对空格的要求（其中一些甚至对 JSON-RPC 无效）。

我可以编写一个分隔符检查来平衡括号和引号（当然，处理转义和引号），或者只是从头开始编写一个 JSON 解析器（或者从另一种语言移植一个，或者修改 http://code.google.com/p/json-sans-eval/），但我可以'不相信以前没有人这样做过。

编辑：我自己制作了两个版本，http://pastebin.com/fqjKYiLw 基于 json-sans-eval，http://pastebin.com/8H4QT82b 基于 Crockford 的参考递归下降解析器 json_parse.js。我仍然更愿意使用经过测试和其他人使用过的东西，而不是自己编写代码，所以我将这个问题留待解决。

Answer 1

在寻找替代方案并没有找到任何有用的东西之后，我决定编写一堆不同的实现并对其进行测试，然后我修改了 Crockford 的参考递归下降解析器（如问题中所述, available here)。

这不是最快的，但在我进行的每项测试中都足够快。更重要的是，它捕获了明显错误的 JSON，当这与不完整的 JSON 并没有歧义时，它比大多数其他替代方案要好得多。最重要的是，它只需要对知名且经过测试的代码库进行很少且非常简单的更改，这让我对其正确性更有信心。

不过，如果有人知道比我更好的库（并且只是被许多项目使用而不是只有我一个人将被视为主要资格），我很想知道它。

Answer 2

这是一个简单的 JSON 对象分隔符。它假定您收到了一系列格式正确的 JSON 对象（不是数组）。

function JSONObjectSepaator() {

    this.onObject = function (JSONStr) {};

    this.reset = function () {
        this.brace_count = 0;
        this.inString = false;
        this.escaped = false;
        this.buffer = "";
    };

    this.receive = function (S) {
        var i;
        var pos=0;
        for (i = 0; i < S.length; i++) {
            var c = S[i];
            if (this.inString) {
                if (this.escaped) {
                    this.escaped = false;
                } else {
                    if (c == "\\") {
                        this.escaped = true;
                    } else if (c == "\"") {
                        this.inString = false;
                    }
                }
            } else {
                if (c == "{") {
                    this.brace_count++;
                } else if (c == "}") {
                    this.brace_count--;
                    if (this.brace_count === 0) {
                        this.buffer += S.substring(pos,i+1);
                        this.onObject(this.buffer);
                        this.buffer = "";
                        pos=i+1;
                    }
                } else if (c == "\"") {
                    this.inString = true;                   
                } 
            }
        }
        this.buffer += S.substring(pos);
    };

    this.reset();
    return this;
}

要使用它，你可以这样做：

var separator = new JSONObjectSepaator();
separator.onObject = function (o) {
    alert("Object received: "+o);
};

separator.receive('{"id":1,"result":{"answer":23},"error":null, "x');
separator.receive('x":"\\\""}{"id":2,"result":{"answer":42},"error":null}{"id":');
separator.receive('3,"result":{"answer":43},"err{or":3}');

Answer 3

务实的回答：使用python

    pos = 0
    try:
        while not pos == len(str(body)):
            # raw_decode will parse as much of the line as possible and return how much was left
            j, json_len = decoder.raw_decode(str(body)[pos:])
            pos += json_len
            # "j" holds your object

我正在编写一些代码来解析从流中保存的大量 JSON 文件，每个流中包含 1 到 50 个 JSON 对象。 这是一个 JavaScript hack，但它适用于我的目的（依赖于包含“坏”JSON 位置的错误消息。如果错误字符是“{”那么我知道这可能是开始一个新对象）：

    let contents = ""; // your JSON string
    let startIndex = 0;
    let endIndex = contents.length;

    do {
        let obj;
        try {
            let str = contents.slice(startIndex, endIndex);
            obj = JSON.parse(str);
            startIndex = endIndex;
            endIndex = contents.length;
            console.log("successfully parsed", obj);
        }
        catch (e) {
            let match = e.toString().match(/^SyntaxError: Unexpected token { in JSON at position (\d+)$/);
            if (match && match.length == 2) {
                endIndex = parseInt(match[1]) + startIndex;
            }
            else throw e;
        }
    } while (startIndex < endIndex);