解析 Nodejs 的大型 JSON 文件

我解决了这个问题使用的 分离式核磁共振模块。管道您的流成分裂，它将“ 分解一个流并重新组装它，以便每一行都是一个块”。

示例代码:

var fs = require('fs')
, split = require('split')
;


var stream = fs.createReadStream(filePath, {flags: 'r', encoding: 'utf-8'});
var lineStream = stream.pipe(split());
linestream.on('data', function(chunk) {
var json = JSON.parse(chunk);
// ...
});

我也有类似的需求，我需要读取节点 js 中的大型 json 文件，分块处理数据，调用 api 并保存到 mongodb 中。 Json 说:

{
"customers":[
{ /*customer data*/},
{ /*customer data*/},
{ /*customer data*/}....
]
}

现在，我使用 JsonStream 和 EventStream 来同步实现这一点。

var JSONStream = require("JSONStream");
var es = require("event-stream");


fileStream = fs.createReadStream(filePath, { encoding: "utf8" });
fileStream.pipe(JSONStream.parse("customers.*")).pipe(
es.through(function(data) {
console.log("printing one customer object read from file ::");
console.log(data);
this.pause();
processOneCustomer(data, this);
return data;
}),
function end() {
console.log("stream reading ended");
this.emit("end");
}
);


function processOneCustomer(data, es) {
DataModel.save(function(err, dataModel) {
es.resume();
});
}

我意识到，如果可能的话，您希望避免将整个 JSON 文件读入内存，但是如果您有可用的内存，那么从性能方面来说，这可能不是一个坏主意。在 json 文件上使用 node.js 的 need ()可以非常快地将数据加载到内存中。

我运行了两个测试，以查看从一个81MB 的 geojson 文件中打印出每个特性的属性时的性能。

在第一个测试中，我使用 var data = require('./geo.json')将整个 Geojson 文件读入内存。这需要3330毫秒，然后从每个特性中打印出一个属性需要804毫秒，总共需要4134毫秒。但是，node.js 似乎使用了411MB 的内存。

在第二个测试中，我在 JSONStream + event-stream 中使用了@arcseldon 的答案。我修改了 JSONPath 查询，以便只选择我需要的内容。这一次内存从来没有超过82MB，然而，整个事情现在需要70秒才能完成！

如果您可以控制输入文件，并且它是一个对象数组，则可以更容易地解决这个问题。安排在一行中输出每条记录的文件，如下所示:

[
{"key": value},
{"key": value},
...

这仍然是有效的 JSON。

然后，使用 node.js readline 模块一次处理一行。

var fs = require("fs");


var lineReader = require('readline').createInterface({
input: fs.createReadStream("input.txt")
});


lineReader.on('line', function (line) {
line = line.trim();


if (line.charAt(line.length-1) === ',') {
line = line.substr(0, line.length-1);
}


if (line.charAt(0) === '{') {
processRecord(JSON.parse(line));
}
});


function processRecord(record) {
// Process the records one at a time here!
}

我编写了一个模块来实现这个功能，称为 BFJ。具体来说，bfj.match方法可以用来将大型流分解为 JSON 的离散块:

const bfj = require('bfj');
const fs = require('fs');


const stream = fs.createReadStream(filePath);


bfj.match(stream, (key, value, depth) => depth === 0, { ndjson: true })
.on('data', object => {
// do whatever you need to do with object
})
.on('dataError', error => {
// a syntax error was found in the JSON
})
.on('error', error => {
// some kind of operational error occurred
})
.on('end', error => {
// finished processing the stream
});

在这里，bfj.match返回一个可读的对象模式流，它将接收解析后的数据项，并传递3个参数:

1. 包含输入 JSON 的可读流。

2. 一个谓词，指示来自解析的 JSON 的哪些项将被推送到结果流。

3. 一个选项对象，指示输入为以换行符分隔的 JSON (这是为了处理问题中的格式 B，格式 A 不需要它)。

在被调用时，bfj.match将从输入流的深度优先解析 JSON，用每个值调用谓词，以确定是否将该项推送到结果流。谓词传递三个参数:

1. 属性键或数组索引(对于顶级项目，这将是 undefined)。

2. 价值本身。

3. JSON 结构中项的深度(顶级项为零)。

当然，根据需求，也可以根据需要使用更复杂的谓词。如果希望对属性键执行简单的匹配，还可以传递字符串或正则表达式而不是谓词函数。

https.get(url1 , function(response) {
var data = "";
response.on('data', function(chunk) {
data += chunk.toString();
})
.on('end', function() {
console.log(data)
});
});

使用@josh3736作为回答，但是对于 ES2021和 Node.js 16 + ，使用异步/等待 + AirBnb 规则:

import fs from 'node:fs';


const file = 'file.json';


/**
* @callback itemProcessorCb
* @param {object} item The current item
*/


/**
* Process each data chunk in a stream.
*
* @param {import('fs').ReadStream} readable The readable stream
* @param {itemProcessorCb} itemProcessor A function to process each item
*/
async function processChunk(readable, itemProcessor) {
let data = '';
let total = 0;


// eslint-disable-next-line no-restricted-syntax
for await (const chunk of readable) {
// join with last result, remove CR and get lines
const lines = (data + chunk).replace('\r', '').split('\n');


// clear last result
data = '';


// process lines
let line = lines.shift();
const items = [];


while (line) {
// check if isn't a empty line or an array definition
if (line !== '' && !/[\[\]]+/.test(line)) {
try {
// remove the last comma and parse json
const json = JSON.parse(line.replace(/\s?(,)+\s?$/, ''));
items.push(json);
} catch (error) {
// last line gets only a partial line from chunk
// so we add this to join at next loop
data += line;
}
}


// continue
line = lines.shift();
}


total += items.length;


// Process items in parallel
await Promise.all(items.map(itemProcessor));
}


console.log(`${total} items processed.`);
}


// Process each item
async function processItem(item) {
console.log(item);
}


// Init
try {
const readable = fs.createReadStream(file, {
flags: 'r',
encoding: 'utf-8',
});


processChunk(readable, processItem);
} catch (error) {
console.error(error.message);
}

对于 JSON 来说，比如:

[
{ "name": "A", "active": true },
{ "name": "B", "active": false },
...
]