Node.js 连接两个（或n个）流
2条溪流： 给定可读的Node.js 连接两个（或n个）流,node.js,stream,eventemitter,Node.js,Stream,Eventemitter,2条溪流： 给定可读的stream1和stream2，获取包含stream1和stream2连接的流的惯用（简洁）方法是什么 我不能做stream1.管道（外扩）；stream2.pipe（outStream），因为这样流内容就混在一起了 n个流： 给定一个发射不确定数量流的 eventEmitter.emit('stream', stream1) eventEmitter.emit('stream', stream2) eventEmitter.emit('stream', stream3)
stream1stream2stream1stream2stream1.管道（外扩）；stream2.pipe（outStream）eventEmitter.emit('stream', stream1)
eventEmitter.emit('stream', stream2)
eventEmitter.emit('stream', stream3)
...
eventEmitter.emit('end')
你也许可以让它更简洁，但这里有一个可行的方法：
var util = require('util');
var EventEmitter = require('events').EventEmitter;
function ConcatStream(streamStream) {
EventEmitter.call(this);
var isStreaming = false,
streamsEnded = false,
that = this;
var streams = [];
streamStream.on('stream', function(stream){
stream.pause();
streams.push(stream);
ensureState();
});
streamStream.on('end', function() {
streamsEnded = true;
ensureState();
});
var ensureState = function() {
if(isStreaming) return;
if(streams.length == 0) {
if(streamsEnded)
that.emit('end');
return;
}
isStreaming = true;
streams[0].on('data', onData);
streams[0].on('end', onEnd);
streams[0].resume();
};
var onData = function(data) {
that.emit('data', data);
};
var onEnd = function() {
isStreaming = false;
streams[0].removeAllListeners('data');
streams[0].removeAllListeners('end');
streams.shift();
ensureState();
};
}
util.inherits(ConcatStream, EventEmitter);
流推正在流流发送streamsendstreamsendendpauseresumeEventEmitterConcatStreamstreamendn=2var CombinedStream = require('combined-stream');
var fs = require('fs');
var combinedStream = CombinedStream.create();
combinedStream.append(fs.createReadStream('file1.txt'));
combinedStream.append(fs.createReadStream('file2.txt'));
combinedStream.pipe(fs.createWriteStream('combined.txt'));
.endvar stream1ThenStream2 = streamee.concatenate([stream1, stream2]);
var CombinedStream = require('combined-stream2');
var fs = require('fs');
var combinedStream = CombinedStream.create();
combinedStream.append(fs.createReadStream('file1.txt'));
combinedStream.append(fs.createReadStream('file2.txt'));
combinedStream.pipe(fs.createWriteStream('combined.txt'));
这可以用香草nodej来完成
import { PassThrough } from 'stream'
const merge = (...streams) => {
let pass = new PassThrough()
let waiting = streams.length
for (let stream of streams) {
pass = stream.pipe(pass, {end: false})
stream.once('end', () => --waiting === 0 && pass.emit('end'))
}
return pass
}
如果您不关心流中数据的顺序，那么在中只需一个简单的操作就可以了
干杯；） 使用ECMA 15+并结合Ivo和Feng的良好答案，对香草NODEJ进行 该类是一个普通流，它不会以任何方式修改流
const { PassThrough } = require('stream');
const concatStreams = (streamArray, streamCounter = streamArray.length) => streamArray
.reduce((mergedStream, stream) => {
// pipe each stream of the array into the merged stream
// prevent the automated 'end' event from firing
mergedStream = stream.pipe(mergedStream, { end: false });
// rewrite the 'end' event handler
// Every time one of the stream ends, the counter is decremented.
// Once the counter reaches 0, the mergedstream can emit its 'end' event.
stream.once('end', () => --streamCounter === 0 && mergedStream.emit('end'));
return mergedStream;
}, new PassThrough());
const mergedStreams = concatStreams([stream1, stream2, stream3]);
下面的代码适用于我：）。从前面给出的所有答案中获取输入
const pipeStreams = (streams) => {
const out = new PassThrough()
// Piping the first stream to the out stream
// Also prevent the automated 'end' event of out stream from firing
streams[0].pipe(out, { end: false })
for (let i = 0; i < streams.length - 2; i++) {
// On the end of each stream (until the second last) pipe the next stream to the out stream
// Prevent the automated 'end' event of out stream from firing
streams[i].on('end', () => {
streams[i + 1].pipe(out, { end: false })
})
}
// On the end of second last stream pipe the last stream to the out stream.
// Don't prevent the 'end flag from firing'
streams[streams.length - 2].on('end', () => {
streams[streams.length - 1].pipe(out)
})
return out
}
constpipestreams=（streams）=>{
const out=new PassThrough（）
//将第一条流输送到输出流
//还可以防止触发out stream的自动“结束”事件
流[0]。管道（输出，{end:false}）
for（设i=0；i{
流[i+1]。管道（输出，{end:false}）
})
}
//在第二个最后一个流的末端，将最后一个流输送到输出流。
//不要阻止“结束标志发射”
streams[streams.length-2]。在（'end'，（）=>{
streams[streams.length-1]。管道（输出）
})
返回
}
export function joinedStream(...streams: Readable[]): Readable {
function pipeNext(): void {
const nextStream = streams.shift();
if (nextStream) {
nextStream.pipe(out, { end: false });
nextStream.on('end', function() {
pipeNext();
});
} else {
out.end();
}
}
const out = new PassThrough();
pipeNext();
return out;
}
现在可以使用异步迭代器轻松地完成此操作
异步函数*concatStreams（可读）{
for（可读内容的常量）{
对于wait（const chunk of readable）{yield chunk}
}
}
const fs=require（'fs'））
const stream=require（'stream'）
const files=['file1.txt'，'file2.txt'，'file3.txt']
const iterable=wait concatStreams（files.map（f=>fs.createReadStream（f）））
//将异步iterable转换为可读流
const mergedStream=stream.Readable.from（iterable）
有关异步迭代器的更多信息：谢谢Aaron！我有点希望会有一些现有的库，这样我可以用三行代码来解决它。如果没有，我想我可能会将您的解决方案提取到一个包中。我可以在麻省理工许可证下使用你的代码吗？啊，找到了流库。看看我的答案。@JoLiss我也先找了些东西，但没找到那个选项。如果你还想的话，你当然可以在库中使用我的代码。谢谢，我会查出来的。我想这就是节点0.10？是的节点0.10，但您可以将旧式流包装为0.10+流，如READMEShouldn中所述。您不是从reduce返回了一些内容吗？这看起来像是未定义的
joinedexport function joinedStream(...streams: Readable[]): Readable {
function pipeNext(): void {
const nextStream = streams.shift();
if (nextStream) {
nextStream.pipe(out, { end: false });
nextStream.on('end', function() {
pipeNext();
});
} else {
out.end();
}
}
const out = new PassThrough();
pipeNext();
return out;
}