我有一个文件，该文件以JSON形式存储许多JavaScript对象，我需要读取该文件，创建每个对象并对其进行处理（在我的情况下，将它们插入db中）。 JavaScript对象可以表示为以下格式：
格式A：
[{name: 'thing1'},
....
{name: 'thing999999999'}]
或格式B：
{name: 'thing1'} // <== My choice.
...
{name: 'thing999999999'}
请注意，...表示很多JSON对象。我知道我可以将整个文件读入内存，然后像这样使用JSON.parse()：
fs.readFile(filePath, 'utf-8', function (err, fileContents) {
if (err) throw err;
console.log(JSON.parse(fileContents));
});
但是，文件可能很大，我希望使用流来完成此操作。我在流中看到的问题是文件内容随时都可能被分解成数据块，那么如何在此类对象上使用JSON.parse()？
理想情况下，每个对象将作为一个单独的数据块读取，但是我不确定如何做到这一点。
var importStream = fs.createReadStream(filePath, {flags: 'r', encoding: 'utf-8'});
importStream.on('data', function(chunk) {
var pleaseBeAJSObject = JSON.parse(chunk);
// insert pleaseBeAJSObject in a database
});
importStream.on('end', function(item) {
console.log("Woot, imported objects into the database!");
});*/
注意，我希望防止将整个文件读入内存。时间效率对我来说并不重要。是的，我可以尝试一次读取多个对象并一次插入所有对象，但这是性能上的调整-我需要一种方法来确保不会引起内存过载，无论文件中包含多少个对象。
我可以选择使用FormatA或FormatB或其他方式，只需在您的答案中指定。谢谢！
要逐行处理文件，您只需要将文件的读取与作用于该输入的代码分离开。您可以通过缓冲输入直到碰到换行符来完成此操作。假设每行有一个JSON对象（基本上是格式B）：
var stream = fs.createReadStream(filePath, {flags: 'r', encoding: 'utf-8'});
var buf = '';
stream.on('data', function(d) {
buf += d.toString(); // when data is read, stash it in a string buffer
pump(); // then process the buffer
});
function pump() {
var pos;
while ((pos = buf.indexOf('\n')) >= 0) { // keep going while there's a newline somewhere in the buffer
if (pos == 0) { // if there's more than one newline in a row, the buffer will now start with a newline
buf = buf.slice(1); // discard it
continue; // so that the next iteration will start with data
}
processLine(buf.slice(0,pos)); // hand off the line
buf = buf.slice(pos+1); // and slice the processed data off the buffer
}
}
function processLine(line) { // here's where we do something with a line
if (line[line.length-1] == '\r') line=line.substr(0,line.length-1); // discard CR (0x0D)
if (line.length > 0) { // ignore empty lines
var obj = JSON.parse(line); // parse the JSON
console.log(obj); // do something with the data here!
}
}
每次文件流从文件系统接收数据时，都会将其存储在缓冲区中，然后调用pump。
如果缓冲区中没有换行符，则pump只会返回而不执行任何操作。下次流获取数据时，会将更多数据（可能还有换行符）添加到缓冲区，然后我们将有一个完整的对象。
[如果有换行符，则pump从开头到换行符将缓冲区切开，并将其交给process。然后，它再次检查缓冲区中是否还有换行符（while循环）。这样，我们可以处理在当前块中读取的所有行。
最后，process每条输入线被调用一次。如果存在，它将去除回车符（以避免出现行尾问题– LF vs CRLF），然后在行中调用JSON.parse。此时，您可以对对象进行任何操作。
请注意，JSON.parse对于接受的输入严格要求；您必须使用标识符标识符和字符串值双引号。换句话说，{name:'thing1'}将引发错误；您必须使用{"name":"thing1"}。
因为一次内存中最多只能有一块数据，所以这将极大地提高内存效率。这也将非常快。快速测试显示，我在15毫秒内处理了10,000行。
[正如我以为编写流式JSON解析器会很有趣，我也认为也许应该快速搜索一下是否已有一个可用的。
原来有。
由于我刚刚找到它，显然我没有使用过它，因此我无法评论其质量，但是我很想知道它是否有效。
它确实可以使用以下Javascript和_.isString：
_.isString如果流是对象数组，则将记录对象进入时的状态。因此，唯一要缓冲的是一次只有一个对象。
截至2014年10月为止，您可以执行以下操作（使用JSONStream）-stream.pipe(JSONStream.parse('*'))
.on('data', (d) => {
console.log(typeof d);
console.log("isString: " + _.isString(d))
});
https://www.npmjs.org/package/JSONStream
[通过工作示例进行演示：
var fs = require('fs'),
JSONStream = require('JSONStream'),
var getStream() = function () {
var jsonData = 'myData.json',
stream = fs.createReadStream(jsonData, {encoding: 'utf8'}),
parser = JSONStream.parse('*');
return stream.pipe(parser);
}
getStream().pipe(MyTransformToDoWhateverProcessingAsNeeded).on('error', function (err){
// handle any errors
});
data.json：
npm install JSONStream event-stream
hello.js：
{
"greeting": "hello world"
}
我意识到，如果可能的话，您要避免将整个JSON文件读入内存，但是，如果您有可用的内存，那么就性能而言可能不是一个坏主意。在json文件上使用node.js的require（）可以将数据真正快速地加载到内存中。
我进行了两次测试，以查看从81MB geojson文件的每个功能中打印出属性时的性能。
在第一个测试中，我使用var fs = require('fs'),
JSONStream = require('JSONStream'),
es = require('event-stream');
var getStream = function () {
var jsonData = 'data.json',
stream = fs.createReadStream(jsonData, {encoding: 'utf8'}),
parser = JSONStream.parse('*');
return stream.pipe(parser);
};
getStream()
.pipe(es.mapSync(function (data) {
console.log(data);
}));
$ node hello.js
// hello world
将整个geojson文件读入内存。这花费了3330毫秒，然后从每个功能中打印出一个属性花费了804毫秒，总计4134毫秒。但是，似乎node.js正在使用411MB的内存。
[在第二个测试中，我将@arcseldon的答案与JSONStream +事件流一起使用。我修改了JSONPath查询以仅选择我需要的内容。这次的内存从未超过82MB，但是现在整个过程花了70秒！
我有类似的要求，我需要在node js中读取一个大的json文件，并分块处理数据，并调用api并保存在mongodb中。inputFile.json就像：
var data = require('./geo.json')现在，我使用JsonStream和EventStream同步实现此目的。
{
"customers":[
{ /*customer data*/},
{ /*customer data*/},
{ /*customer data*/}....
]
}
我编写了一个可以执行此操作的模块，称为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();
});
}
。具体来说，方法BFJ可用于将大型流分解为JSON的离散块：
bfj.matchconst 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
});
返回一个可读的对象模式流，该流将接收已解析的数据项，并传递3个参数：
包含输入JSON的可读流。
一个谓词，它指示已解析的JSON中的哪些项目将被推送到结果流。
一个选项对象，指示输入为换行符分隔的JSON（用于处理问题中的格式B，格式A不是必需的。
] >>[被调用时，bfj.match将从输入流开始首先解析JSON，并使用每个值调用谓词以确定是否将该项推入结果流。谓词传递了三个参数：
属性键或数组索引（对于顶级项目，它将为bfj.match。
值本身。
JSON结构中项目的深度（顶级项目为零）。
当然，根据需要，也可以使用更复杂的谓词。如果要对属性键执行简单匹配，还可以传递字符串或正则表达式而不是谓词函数。
我使用undefined解决了这个问题。用管道将流分成若干部分，它将“ 分解流并重新组装，使每一行都是一个块
如果您可以控制输入文件，并且它是一个对象数组，则可以更轻松地解决此问题。安排将每条记录的文件输出到一行，如下所示：
我认为您需要使用数据库。在这种情况下，MongoDB是一个不错的选择，因为它与JSON兼容。