Estoy pirateando un programa de nodo que se utiliza smtp-protocolpara capturar correos electrónicos SMTP y actuar sobre los datos del correo. La biblioteca proporciona los datos del correo como una secuencia, y no sé cómo convertirlos en una cadena.

Actualmente lo estoy escribiendo en stdout con stream.pipe(process.stdout, { end: false }), pero como dije, necesito los datos de la transmisión en una cadena, que puedo usar una vez que la transmisión haya finalizado.

¿Cómo recopilo todos los datos de un flujo de Node.js en una cadena?

(Esta respuesta es de hace años, cuando era la mejor respuesta. Ahora hay una mejor respuesta debajo de esta. No me he mantenido al día con node.js y no puedo eliminar esta respuesta porque está marcada como "correcta en esta pregunta ". Si está pensando en hacer clic hacia abajo, ¿qué quiere que haga?)

La clave es utilizar los eventos datay endde una secuencia legible . Escuche estos eventos:

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

Cuando reciba el dataevento, agregue la nueva porción de datos a un búfer creado para recopilar los datos.

Cuando reciba el endevento, convierta el búfer completo en una cadena, si es necesario. Luego haz lo que tengas que hacer con él.

Otra forma sería convertir la secuencia en una promesa (consulte el ejemplo a continuación) y usar then(o await) para asignar el valor resuelto a una variable.

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)

Ninguno de los anteriores funcionó para mí. Necesitaba usar el 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 esto sea más útil que la respuesta anterior:

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

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

Tenga en cuenta que la concatenación de cadenas no es la forma más eficiente de recopilar las partes de la cadena, pero se usa para simplificar (y quizás a su código no le importa la eficiencia).

Además, este código puede producir fallas impredecibles para texto que no es ASCII (asume que cada carácter cabe en un byte), pero tal vez eso tampoco le importe.

Normalmente uso esta función simple para transformar una secuencia en una cadena:

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

Ejemplo de uso:

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

Y otro más para cadenas que usan promesas:

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));

elimine el .toString()para usar con datos binarios si es necesario.

actualización : @AndreiLED señaló correctamente que esto tiene problemas con las cadenas. No pude obtener una secuencia que devuelva cadenas con la versión del nodo que tengo, pero la API señala que esto es posible.

De la documentación de nodejs , debe hacer esto: recuerde siempre una cadena sin saber que la codificación es solo un montón 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);
})

Los flujos no tienen una .toString()función simple (que entiendo) ni algo así como una .toStringAsync(cb)función (que no entiendo).

Entonces creé mi propia función de ayuda:

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);
});

Tuve más suerte usando así:

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

Yo uso el nodo v9.11.1y readstreames la respuesta de una http.getdevolución de llamada.

La solución más limpia puede ser utilizar el paquete "string-stream", que convierte una secuencia en una cadena con una promesa.

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
})

Manera fácil con la popular (más de 5 millones de descargas semanales) y la biblioteca ligera get-stream :

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
})();

¿Qué tal algo como un reductor de corriente?

A continuación, se muestra un ejemplo de cómo utilizar las clases de ES6.

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'));
  })
);

Esto funcionó para mí y se basa en los documentos de 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');

Bien hecho Sebastian J arriba.

Tuve el "problema del búfer" con algunas líneas de código de prueba que tenía, agregué la información de codificación y lo resolvió, ver más abajo.

Demuestra el problema

software

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

entrada

hello world

salida

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

Demuestre la solución

software

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

entrada

hello world

salida

string hello world

Todas las respuestas enumeradas parecen abrir la transmisión legible en modo de flujo, que no es el predeterminado en NodeJS y puede tener limitaciones, ya que carece de soporte de contrapresión que proporciona NodeJS en el modo de transmisión legible en pausa. Aquí hay una implementación que utiliza Just Buffers, Native Stream y Native Stream Transforms y compatibilidad con el 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

Qué piensas sobre esto ?

// 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 el paquete bastante popularstream-buffers que probablemente ya tenga en las dependencias de su proyecto, esto es bastante sencillo:

// 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()));

En mi caso, los encabezados de respuesta del tipo de contenido eran Content-Type: text / plain . Entonces, he leído los datos de Buffer como:

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