Estou hackeando um programa Node que usa smtp-protocolpara capturar emails SMTP e agir sobre os dados de email. A biblioteca fornece os dados de correio como um fluxo, e não sei como colocá-los em uma string.

No momento, estou escrevendo para stdout com stream.pipe(process.stdout, { end: false }), mas, como disse, preciso dos dados do fluxo em uma string, que posso usar assim que o fluxo terminar.

Como faço para coletar todos os dados de um fluxo Node.js em uma string?

(Esta resposta é de anos atrás, quando era a melhor resposta. Agora há uma resposta melhor abaixo. Eu não acompanhei o node.js e não posso excluir esta resposta porque está marcada como "correto nesta pergunta ". Se você está pensando em clicar, o que você quer que eu faça?)

A chave é usar os eventos datae endde um fluxo legível . Ouça estes eventos:

stream.on('data', (chunk) => { ... });
stream.on('end', () => { ... });

Ao receber o dataevento, adicione o novo bloco de dados a um Buffer criado para coletar os dados.

Ao receber o endevento, converta o Buffer preenchido em uma string, se necessário. Em seguida, faça o que você precisa fazer com ele.

Outra forma seria converter o fluxo em uma promessa (consulte o exemplo abaixo) e usar then(ou await) para atribuir o valor resolvido a uma variável.

function streamToString (stream) {
  const chunks = []
  return new Promise((resolve, reject) => {
    stream.on('data', chunk => chunks.push(chunk))
    stream.on('error', reject)
    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
  })
}

const result = await streamToString(stream)

Nenhuma das opções acima funcionou para mim. Eu precisava usar o objeto Buffer:

  const chunks = [];

  readStream.on("data", function (chunk) {
    chunks.push(chunk);
  });

  // Send the buffer or you can put it into a var
  readStream.on("end", function () {
    res.send(Buffer.concat(chunks));
  });

Espero que seja mais útil do que a resposta acima:

var string = '';
stream.on('data',function(data){
  string += data.toString();
  console.log('stream data ' + part);
});

stream.on('end',function(){
  console.log('final output ' + string);
});

Observe que a concatenação de string não é a maneira mais eficiente de coletar as partes da string, mas é usada para simplificar (e talvez seu código não se importe com a eficiência).

Além disso, esse código pode produzir falhas imprevisíveis para texto não ASCII (ele assume que cada caractere cabe em um byte), mas talvez você também não se importe com isso.

Normalmente, estou usando esta função simples para transformar um stream em uma string:

function streamToString(stream, cb) {
  const chunks = [];
  stream.on('data', (chunk) => {
    chunks.push(chunk.toString());
  });
  stream.on('end', () => {
    cb(chunks.join(''));
  });
}

Exemplo de uso:

let stream = fs.createReadStream('./myFile.foo');
streamToString(stream, (data) => {
  console.log(data);  // data is now my string variable
});

E ainda outro para strings usando promessas:

function getStream(stream) {
  return new Promise(resolve => {
    const chunks = [];

    # Buffer.from is required if chunk is a String, see comments
    stream.on("data", chunk => chunks.push(Buffer.from(chunk)));
    stream.on("end", () => resolve(Buffer.concat(chunks).toString()));
  });
}

Uso:

const stream = fs.createReadStream(__filename);
getStream(stream).then(r=>console.log(r));

remova o .toString()para usar com dados binários, se necessário.

update : @AndreiLED apontou corretamente que há problemas com strings. Não consegui obter um fluxo que retornasse strings com a versão do nó que possuo, mas a API observa que isso é possível.

A partir da documentação do nodejs , você deve fazer isso - lembre-se sempre de uma string sem saber que a codificação é apenas um monte de bytes:

var readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', function(chunk) {
  assert.equal(typeof chunk, 'string');
  console.log('got %d characters of string data', chunk.length);
})

Streams não tem uma .toString()função simples (que eu entendo) nem algo como uma .toStringAsync(cb)função (que eu não entendo).

Então, criei minha própria função auxiliar:

var streamToString = function(stream, callback) {
  var str = '';
  stream.on('data', function(chunk) {
    str += chunk;
  });
  stream.on('end', function() {
    callback(str);
  });
}

// how to use:
streamToString(myStream, function(myStr) {
  console.log(myStr);
});

Tive mais sorte usando assim:

let string = '';
readstream
    .on('data', (buf) => string += buf.toString())
    .on('end', () => console.log(string));

Eu uso o nó v9.11.1e readstreamé a resposta de um http.getretorno de chamada.

A solução mais limpa pode ser usar o pacote "string-stream", que converte um fluxo em uma string com uma promessa.

const streamString = require('stream-string')

streamString(myStream).then(string_variable => {
    // myStream was converted to a string, and that string is stored in string_variable
    console.log(string_variable)

}).catch(err => {
     // myStream emitted an error event (err), so the promise from stream-string was rejected
    throw err
})

Maneira fácil com a biblioteca get-stream popular (mais de 5 milhões de downloads semanais) e leve :

https://www.npmjs.com/package/get-stream

const fs = require('fs');
const getStream = require('get-stream');

(async () => {
    const stream = fs.createReadStream('unicorn.txt');
    console.log(await getStream(stream)); //output is string
})();

Que tal algo como um redutor de fluxo?

Aqui está um exemplo usando classes ES6 como usar um.

var stream = require('stream')

class StreamReducer extends stream.Writable {
  constructor(chunkReducer, initialvalue, cb) {
    super();
    this.reducer = chunkReducer;
    this.accumulator = initialvalue;
    this.cb = cb;
  }
  _write(chunk, enc, next) {
    this.accumulator = this.reducer(this.accumulator, chunk);
    next();
  }
  end() {
    this.cb(null, this.accumulator)
  }
}

// just a test stream
class EmitterStream extends stream.Readable {
  constructor(chunks) {
    super();
    this.chunks = chunks;
  }
  _read() {
    this.chunks.forEach(function (chunk) { 
        this.push(chunk);
    }.bind(this));
    this.push(null);
  }
}

// just transform the strings into buffer as we would get from fs stream or http request stream
(new EmitterStream(
  ["hello ", "world !"]
  .map(function(str) {
     return Buffer.from(str, 'utf8');
  })
)).pipe(new StreamReducer(
  function (acc, v) {
    acc.push(v);
    return acc;
  },
  [],
  function(err, chunks) {
    console.log(Buffer.concat(chunks).toString('utf8'));
  })
);

Isso funcionou para mim e é baseado nos documentos do Node v6.7.0 :

let output = '';
stream.on('readable', function() {
    let read = stream.read();
    if (read !== null) {
        // New stream data is available
        output += read.toString();
    } else {
        // Stream is now finished when read is null.
        // You can callback here e.g.:
        callback(null, output);
    }
});

stream.on('error', function(err) {
  callback(err, null);
})

setEncoding ('utf8');

Muito bem, Sebastian J acima.

Eu tive o "problema de buffer" com algumas linhas de código de teste que eu tinha, e adicionei as informações de codificação e isso resolveu, veja abaixo.

Demonstre o problema

Programas

// process.stdin.setEncoding('utf8');
process.stdin.on('data', (data) => {
    console.log(typeof(data), data);
});

entrada

hello world

resultado

object <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64 0d 0a>

Demonstre a solução

Programas

process.stdin.setEncoding('utf8'); // <- Activate!
process.stdin.on('data', (data) => {
    console.log(typeof(data), data);
});

entrada

hello world

resultado

string hello world

Todas as respostas listadas parecem abrir o fluxo legível no modo de fluxo, que não é o padrão no NodeJS e pode ter limitações, pois não tem suporte de contrapressão que o NodeJS fornece no modo de fluxo legível pausado. Aqui está uma implementação usando Just Buffers, Native Stream e Native Stream Transforms e suporte para o modo de objeto

import {Transform} from 'stream';

let buffer =null;    

function objectifyStream() {
    return new Transform({
        objectMode: true,
        transform: function(chunk, encoding, next) {

            if (!buffer) {
                buffer = Buffer.from([...chunk]);
            } else {
                buffer = Buffer.from([...buffer, ...chunk]);
            }
            next(null, buffer);
        }
    });
}

process.stdin.pipe(objectifyStream()).process.stdout

O que você pensa sobre isso ?

// lets a ReadableStream under stream variable 
const chunks = [];

for await (let chunk of stream) {
    chunks.push(chunk)
}

const buffer  = Buffer.concat(chunks);
const str = buffer.toString("utf-8")

Usando o pacote bastante popularstream-buffers que você provavelmente já tem nas dependências do seu projeto, isso é bastante simples:

// imports
const { WritableStreamBuffer } = require('stream-buffers');
const { promisify } = require('util');
const { createReadStream } = require('fs');
const pipeline = promisify(require('stream').pipeline);

// sample stream
let stream = createReadStream('/etc/hosts');

// pipeline the stream into a buffer, and print the contents when done
let buf = new WritableStreamBuffer();
pipeline(stream, buf).then(() => console.log(buf.getContents().toString()));

No meu caso, os cabeçalhos de resposta do tipo de conteúdo eram Content-Type: text / plain . Então, eu li os dados do Buffer como:

let data = [];
stream.on('data', (chunk) => {
 console.log(Buffer.from(chunk).toString())
 data.push(Buffer.from(chunk).toString())
});