我正在使用 Oboe.js、MongoDB 和 Express.js 试验通过 HTTP 的 JSON 流。

重点是在 MongoDB(Node.js 的 mongodb native 驱动器)中进行查询，将其(JavaScript 数组)通过管道传输到 Express.js 并在其中解析带有 Oboe.js 的浏览器。

我所做的基准比较了 MongoDB 查询服务器端和客户端 JSON 解析中的 streaming 与 blocking。

这是两个基准测试的源代码。 第一个数字 是 1000 万个文档集合100 项(分页)的1000 次查询 的毫秒数 和括号之间的第二个数字，表示在解析 MongoDB 结果数组中的第一项之前的毫秒数。

流式基准服务器端:

// Oboe.js - 20238 (16.887)
// Native - 16703 (16.69)

collection
.find()
.skip(+req.query.offset)
.limit(+req.query.limit)
.stream()
.pipe(JSONStream.stringify())
.pipe(res);

阻塞基准服务器端:

// Oboe.js - 17418 (14.267)
// Native - 13706 (13.698)

collection
.find()
.skip(+req.query.offset)
.limit(+req.query.limit)
.toArray(function (e, docs) {
    res.json(docs);
});

这些结果真的让我吃惊，因为我会认为:

1. Streaming 每次都比 blocking 更快。​​
与原生 JSON.parse 方法相比，
2. Oboe.js 可以更快地解析整个 JSON 数组。
与原生 JSON.parse 方法相比，
3. Oboe.js 可以更快地解析数组中的第一个元素。

谁有解释吗？ 我做错了什么？

这也是两个客户端基准测试的源代码。

流式基准测试客户端:

var limit = 100;
var max = 1000;

var oboeFirstTimes = [];
var oboeStart = Date.now();

function paginate (i, offset, limit) {
    if (i === max) {
        console.log('> OBOE.js time:', (Date.now() - oboeStart));
        console.log('> OBOE.js avg. first time:', (
            oboeFirstTimes.reduce(function (total, time) {
                return total + time;
            }, 0) / max
        ));
        return true;
    }

    var parseStart = Date.now();
    var first = true;
    oboe('/api/spdy-stream?offset=' + offset + '&limit=' + limit)
    .node('![*]', function () {
        if (first) {
            first = false;
            oboeFirstTimes.push(Date.now() - parseStart);
        }
    })
    .done(function () {
        paginate(i + 1, offset + limit, limit);
    });
}

paginate(0, 0, limit);

阻塞基准客户端:

var limit = 100;
var max = 1000;

var nativeFirstTimes = [];
var nativeStart = Date.now();

function paginate (i, offset, limit) {
    if (i === max) {
        console.log('> NATIVE time:', (Date.now() - nativeStart));
        console.log('> NATIVE avg. first time:', (
            nativeFirstTimes.reduce(function (total, time) {
                return total + time;
            }, 0) / max
        ));
        return true;
    }

    var parseStart = Date.now();
    var first = true;

    var req = new XMLHttpRequest();
    req.open('GET', '/api/spdy-stream?offset=' + offset + '&limit=' + limit, true);

    req.onload = function () {
        var json = JSON.parse(req.responseText);
        json.forEach(function () {
            if (first) {
                first = false;
                nativeFirstTimes.push(Date.now() - parseStart);
            }
        });
        paginate(i + 1, offset + limit, limit);
    };

    req.send();
}

paginate(0, 0, limit);

提前致谢!

最佳答案

我在“为什么选择双簧管？”结尾处的双簧管文档中找到了这些评论。部分:

因为它是一个纯 Javascript 解析器，Oboe.js 比 JSON.parse 需要更多的 CPU 时间。对于加载速度非常快的小消息，Oboe.js 的工作速度稍微慢一些，但对于大多数实际情况，使用 i/o 有效地胜过优化 CPU 时间。 SAX 解析器比 Oboe 的基于模式的解析模型需要更少的内存，因为它们不构建解析树。请参阅 Oboe.js 与 SAX 与 DOM。 如果有疑问，请进行基准测试，但不要忘记使用真实的互联网，包括移动设备，并考虑感知性能。

关于使用 Oboe.js、MongoDB 和 Express.js 进行 JSON 流式传输，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/26685022/