Question

我正在使用writable stream编写一个包含node.js的大文件：

var fs     = require('fs');
var stream = fs.createWriteStream('someFile.txt', { flags : 'w' });

var lines;
while (lines = getLines()) {
    for (var i = 0; i < lines.length; i++) {
        stream.write( lines[i] );
    }
}

我想知道这个方案在没有使用drain事件的情况下是否安全？如果不是（我认为是这种情况），将任意大数据写入文件的模式是什么？

Answer 1

这就是我最终做到的。其背后的想法是创建实现ReadStream接口的可读流，然后使用pipe()方法将数据传输到可写流。

var fs = require('fs');
var writeStream = fs.createWriteStream('someFile.txt', { flags : 'w' });
var readStream = new MyReadStream();

readStream.pipe(writeStream);
writeStream.on('close', function () {
    console.log('All done!');
});

MyReadStream课程的示例可以从mongoose QueryStream中获取。

Answer 2

排水背后的想法是你会用它来测试：

var fs = require('fs');
var stream = fs.createWriteStream('someFile.txt', {flags: 'w'});

var lines;
while (lines = getLines()) {
    for (var i = 0; i < lines.length; i++) {
        stream.write(lines[i]); //<-- the place to test
    }
}

你不是。因此，您需要重新构建以使其“可重入”。

var fs = require('fs');
var stream = fs.createWriteStream('someFile.txt', {flags: 'w'});

var lines;
while (lines = getLines()) {
    for (var i = 0; i < lines.length; i++) {
        var written = stream.write(lines[i]); //<-- the place to test
        if (!written){
           //do something here to wait till you can safely write again
           //this means prepare a buffer and wait till you can come back to finish
           //  lines[i] -> remainder
        }
    }
}

但是，这是否意味着您需要在等待时继续缓冲getLines？

var fs = require('fs');
var stream = fs.createWriteStream('someFile.txt', {flags: 'w'});

var lines,
    buffer = {
     remainingLines = []
    };
while (lines = getLines()) {
    for (var i = 0; i < lines.length; i++) {
        var written = stream.write(lines[i]); //<-- the place to test
        if (!written){
           //do something here to wait till you can safely write again
           //this means prepare a buffer and wait till you can come back to finish
           //  lines[i] -> remainder
           buffer.remainingLines = lines.slice(i);
           break;
           //notice there's no way to re-run this once we leave here.
        }
    }
}

stream.on('drain',function(){
  if (buffer.remainingLines.length){
    for (var i = 0; i < buffer.remainingLines.length; i++) {
      var written = stream.write(buffer.remainingLines[i]); //<-- the place to test
      if (!written){
       //do something here to wait till you can safely write again
       //this means prepare a buffer and wait till you can come back to finish
       //  lines[i] -> remainder
       buffer.remainingLines = lines.slice(i);
      }
    }
  }
});

Answer 3

[编辑] 更新的Node.js writable.write(...) API docs说：

[返回]是严格的建议。你可以继续写，即使它返回false。但是，写入将缓冲在内存中，因此最好不要过度执行此操作。相反，在写入更多数据之前等待排水事件。

[原创] 来自stream.write(...) documentation（强调我的）：

如果字符串已刷新到内核缓冲区，则返回true。返回false表示内核缓冲区已满，数据将在以后发送。

我将此解释为“如果给定的字符串立即写入底层OS缓冲区，则”write“函数返回true;如果尚未写入，则false但将返回{{1}}由写入函数写的（例如，可能是由WriteStream为您缓冲的），这样您就不必再次调用“write”了。

Answer 4

我发现流是处理大文件的一种表现不佳的方式 - 这是因为你无法设置足够的输入缓冲区大小（至少我不知道这样做的好方法）。这就是我的工作：

var fs = require('fs');

var i = fs.openSync('input.txt', 'r');
var o = fs.openSync('output.txt', 'w');

var buf = new Buffer(1024 * 1024), len, prev = '';

while(len = fs.readSync(i, buf, 0, buf.length)) {

    var a = (prev + buf.toString('ascii', 0, len)).split('\n');
    prev = len === buf.length ? '\n' + a.splice(a.length - 1)[0] : '';

    var out = '';
    a.forEach(function(line) {

        if(!line)
            return;

        // do something with your line here

        out += line + '\n';
    });

    var bout = new Buffer(out, 'ascii');
    fs.writeSync(o, bout, 0, bout.length);
}

fs.closeSync(o);
fs.closeSync(i);

Answer 5

处理此问题的最简洁方法是让您的线路生成器readable stream - 让我们称之为lineReader。然后，以下内容将自动处理缓冲区并为您精确排出：

lineReader.pipe(fs.createWriteStream('someFile.txt'));

如果你不想制作一个可读的流，你可以听取write的输出以获得缓冲区充满度，并像这样回复：

var i = 0, n = lines.length;
function write () {
  if (i === n) return;  // A callback could go here to know when it's done.
  while (stream.write(lines[i++]) && i < n);
  stream.once('drain', write);
}
write();  // Initial call.

可以找到这种情况的更长例子here。

Answer 6

这个问题的几个建议答案完全忽略了关于流的观点。

此模块可以帮助https://www.npmjs.org/package/JSONStream

但是，让我们假设所描述的情况并自己编写代码。您正在将MongoDB作为流读取，默认情况下ObjectMode = true。

如果您尝试直接传输到文件，这会导致问题 - 例如“无效的非字符串/缓冲区块”错误。

解决这类问题非常简单。

只需在可读和可写之间放置另一个Transform，以使Object可读地适应String。

示例代码解决方案：

var fs = require('fs'),
    writeStream = fs.createWriteStream('./out' + process.pid, {flags: 'w', encoding: 'utf-8' }),
    stream = require('stream'),
    stringifier = new stream.Transform();
stringifier._writableState.objectMode = true;
stringifier._transform = function (data, encoding, done) {
    this.push(JSON.stringify(data));
    this.push('\n');
    done();
}
rowFeedDao.getRowFeedsStream(merchantId, jobId)
.pipe(stringifier)
.pipe(writeStream).on('error', function (err) {
   // handle error condition
}

Answer 7

如果您没有输入流，则无法轻松使用管道。以上都没有为我工作，排水事件不会发生。解决如下（基于Tylers答案）：

var lines[]; // some very large array
var i = 0;

function write() {
    if (i < lines.length)  {
        wstream.write(lines[i]), function(err){
            if (err) {
                console.log(err);
            } else {
                i++;
                write();
            }
        });
    } else {
        wstream.end();
        console.log("done");
    }
};
write();

使用Node.js编写大文件

7 个答案: