我需要串行运行两个需要从同一个流中读取数据的命令.将流传输到另一个流后,缓冲区被清空,因此我无法再次从该流中读取数据,因此这不起作用:

var spawn = require('child_process').spawn;
var fs = require('fs');
var request = require('request');

var inputStream = request('http://placehold.it/640x360');
var identify = spawn('identify',['-']);

inputStream.pipe(identify.stdin);

var chunks = [];
identify.stdout.on('data',function(chunk) {
  chunks.push(chunk);
});

identify.stdout.on('end',function() {
  var size = getSize(Buffer.concat(chunks)); //width
  var convert = spawn('convert',['-','-scale',size * 0.5,'png:-']);
  inputStream.pipe(convert.stdin);
  convert.stdout.pipe(fs.createWriteStream('half.png'));
});

function getSize(buffer){
  return parseInt(buffer.toString().split(' ')[2].split('x')[0]);
}

请求抱怨这个

Error: You cannot pipe after data has been emitted from the response.

并改变inputStreamfs.createWriteStream当然会产生同样的问题.我不想写入文件,而是以某种方式重用请求生成的流(或其他任何内容).

有没有办法在完成管道后重复使用可读流？完成上述例子的最佳方法是什么？

如何在使用stream2接口后将node.js缓冲区转换为可读流？

我已经找到了这个答案和stream-buffers模块,但是这个模块基于stream1接口.

我想将数据从亚马逊kinesis流传输到s3日志或bunyan日志.

该示例使用文件写入流或标准输出.我怎么会扼杀我自己的可写流？

//this works
var file = fs.createWriteStream('my.log')
kinesisSource.pipe(file)

这不起作用说没有'on'方法

var stream = {}; //process.stdout works however
stream.writable = true;
stream.write =function(data){
    console.log(data);
};
kinesisSource.pipe(stream);

我必须为我自己的自定义可写流实现什么方法,文档似乎表明我需要实现'write'而不是'on'

目标是:

1. 创建文件读取流.
2. 把它管到gzip(zlib.createGzip())

3. 然后将zlib输出的读取流传输到:

   1)HTTP response对象

   2)和可写文件流以保存gzip压缩输出.

现在我可以做到3.1:

var gzip = zlib.createGzip(),
    sourceFileStream = fs.createReadStream(sourceFilePath),
    targetFileStream = fs.createWriteStream(targetFilePath);

response.setHeader('Content-Encoding', 'gzip');

sourceFileStream.pipe(gzip).pipe(response);

...工作正常,但我还需要将gzip压缩数据保存到文件中,这样我就不需要每次都重新压缩,并能够直接将gzip压缩数据作为响应流.

那么如何在Node中一次将一个可读流传输到两个可写流中？

将sourceFileStream.pipe(gzip).pipe(response).pipe(targetFileStream);在节点0.8.4工作？

正如文档所述,它们都处理将非流插件转换为流.

我试着理解的是,如果我可以.pipe()在某些东西上使用这个方法,那么这不是说它是一个流吗？

如果是这样,我该怎么转换成什么？

乙烯基源流示例:

(来自:https://www.npmjs.com/package/vinyl-buffer)

var browserify = require('browserify')
var source = require('vinyl-source-stream')
var buffer = require('vinyl-buffer')
var uglify = require('gulp-uglify')
var size = require('gulp-size')
var gulp = require('gulp')

gulp.task('build', function() {
  var bundler = browserify('./index.js')

  return bundler.pipe()
    .pipe(source('index.js'))
    .pipe(buffer()) // <---------------------- why?
    .pipe(uglify())
    .pipe(size())
    .pipe(gulp.dest('dist/'))
})

gulp-streamify示例:

(来自:https://www.npmjs.com/package/vinyl-source-stream)

var source = require('vinyl-source-stream')
var streamify = require('gulp-streamify')
var browserify = require('browserify')
var uglify = require('gulp-uglify')
var gulp = …

如果可能的话,我想通过管道将两个Node.js流组合成一个.我正在使用Transform流.

换句话说,我希望我的图书馆能够myStream让人们使用.例如,他们可以写:

process.stdin.pipe(myStream).pipe(process.stdout);

在内部,我正在使用第三方vendorStream做一些工作,插入我自己的逻辑中myInternalStream.那么上面的内容将转化为:

process.stdin.pipe(vendorStream).pipe(myInternalStream).pipe(process.stdout);

我可以这样做吗？我试过了,var myStream = vendorStream.pipe(myInternalStream)但显然不起作用.

换句话说bash,假设我想编写一个程序,检查字母h是否出现在某个stream(tail -n 1 | grep h)的最后一行,我可以创建一个shell脚本:

# myscript.sh
tail -n 1 | grep h

如果人们这样做:

$ printf "abc\ndef\nghi" | . myscript.sh

它只是有效.

这是我到目前为止:

// Combine a pipe of two streams into one stream

var util = require('util')
  , Transform = require('stream').Transform;

var chunks1 = [];
var stream1 = new Transform();
var soFar = '';
stream1._transform …

我正在通过双工字符串管道文件(礼貌地通过),我无法将信息打印到文件stdout 并写入文件.一个或另一个工作得很好.

var fs = require('fs');
var path = require('path');
var through = require('through'); // easy duplexing, i'm young


catify = new through(function(data){
    this.queue(data.toString().replace(/(woof)/gi, 'meow'));
});

var reader = fs.createReadStream('dogDiary.txt'); // woof woof etc.
var writer = fs.createWriteStream(path.normalize('generated/catDiary.txt')); // meow meow etc.

// yay!
reader.pipe(catify).pipe(writer)

// blank file. T_T
reader.pipe(catify).pipe(process.stdout).pipe(writer) 

我假设这是因为process.stdout是一个可写的流,但我不知道如何做我想要的(我试过传递{end: false}无济于事).

仍在努力将我的头包裹在溪流周围,所以请原谅我,如果我错过了一些明显的东西:)

我们可以使用require函数访问本地模块,但不能通过它访问全局模块.我在某处读到要使用全局模块,我们需要将其设置为本地,然后通过require函数导入它.因此,如果我们无法直接访问全局模块,那么使用它的需求是什么.

前提

我正在尝试找到在Node.js中过早终止一系列管道流(管道)的正确方法:有时我想在流完成之前优雅地中止流.具体来说,我正在处理大部分objectMode: true和非原生的并行流,但这并不重要.

问题

问题是当我unpipe在管道中时,数据保留在每个流的缓冲区中并被drain编辑.对于大多数中间流(例如/ ),这可能没问题,但是最后一个仍然流向其写目标(例如文件或数据库或套接字或w/e).如果缓冲区包含数百或数千个块需要花费大量时间来消耗,则这可能是有问题的.我希望它立即停止,即不要排水; 为什么浪费周期和内存对数据无关紧要？ReadableTransformWritable

根据我去的路线,我收到"写后结束"错误,或者当流找不到现有管道时发生异常.

题

什么是优雅地杀死表单中的流管道的正确方法a.pipe(b).pipe(c).pipe(z)？

解？

我提出的解决方案是3步:

1. unpipe 管道中的每个流以相反的顺序排列
2. 清空实现的每个流的缓冲区 Writable
3. end 每个实现的流 Writable

一些伪代码说明了整个过程:

var pipeline = [ // define the pipeline
  readStream,
  transformStream0,
  transformStream1,
  writeStream
];

// build and start the pipeline
var tmpBuildStream;
pipeline.forEach(function(stream) {
    if ( !tmpBuildStream ) {
        tmpBuildStream = stream;
        continue;
    }
    tmpBuildStream = lastStream.pipe(stream);
});

// sleep, timeout, event, etc...

// tear down the …

我想知道是否可能多个函数可以使用node.js中的单个流.如果是,这怎么办？是否可以管道到多个目的地？

我想在两个不同的并行函数中使用流.我正在使用异步模块进行并行流程.那么可以说在每个函数中发出pipe()语句吗？

提前致谢.