Je pirate un programme Node qui utilise smtp-protocolpour capturer les e-mails SMTP et agir sur les données de messagerie. La bibliothèque fournit les données de messagerie sous forme de flux, et je ne sais pas comment les intégrer dans une chaîne.

Je l'écris actuellement sur stdout avec stream.pipe(process.stdout, { end: false }), mais comme je l'ai dit, j'ai besoin des données de flux dans une chaîne à la place, que je peux utiliser une fois le flux terminé.

Comment collecter toutes les données d'un flux Node.js dans une chaîne?

(Cette réponse date d'il y a des années, quand c'était la meilleure réponse. Il y a maintenant une meilleure réponse en dessous de celle-ci. Je n'ai pas suivi le node.js, et je ne peux pas supprimer cette réponse car elle est marquée "correct sur cette question ". Si vous envisagez de cliquer, que voulez-vous que je fasse?)

La clé est d'utiliser les événements dataet endd'un flux lisible . Écoutez ces événements:

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

Lorsque vous recevez l' dataévénement, ajoutez le nouveau bloc de données à un tampon créé pour collecter les données.

Lorsque vous recevez l' endévénement, convertissez le tampon terminé en une chaîne, si nécessaire. Ensuite, faites ce que vous devez en faire.

Une autre façon serait de convertir le flux en une promesse (reportez-vous à l'exemple ci-dessous) et d'utiliser then(ou await) pour affecter la valeur résolue à une 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)

Aucun de ces éléments n'a fonctionné pour moi. J'avais besoin d'utiliser l'objet 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));
  });

J'espère que cela est plus utile que la réponse ci-dessus:

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

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

Notez que la concaténation de chaînes n'est pas le moyen le plus efficace de collecter les parties de chaîne, mais elle est utilisée pour plus de simplicité (et peut-être que votre code ne se soucie pas de l'efficacité).

En outre, ce code peut produire des échecs imprévisibles pour le texte non ASCII (il suppose que chaque caractère tient dans un octet), mais peut-être que vous ne vous en souciez pas non plus.

J'utilise généralement cette fonction simple pour transformer un flux en une chaîne:

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

Exemple d'utilisation:

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

Et encore un autre pour les chaînes utilisant des promesses:

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

Usage:

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

supprimez le .toString()à utiliser avec des données binaires si nécessaire.

mise à jour : @AndreiLED a correctement souligné que cela avait des problèmes avec les chaînes. Je n'ai pas pu obtenir un flux renvoyant des chaînes avec la version du nœud que j'ai, mais l' API note que c'est possible.

À partir de la documentation de nodejs , vous devriez le faire - souvenez-vous toujours d'une chaîne sans savoir que l'encodage n'est qu'un tas d'octets:

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

Les flux n'ont pas de .toString()fonction simple (que je comprends) ni quelque chose comme une .toStringAsync(cb)fonction (que je ne comprends pas).

J'ai donc créé ma propre fonction d'assistance:

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

J'ai eu plus de chance en utilisant comme ça:

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

J'utilise node v9.11.1et readstreamc'est la réponse d'un http.getrappel.

La solution la plus propre peut être d'utiliser le package "string-stream", qui convertit un flux en chaîne avec une promesse.

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

Un moyen simple avec la bibliothèque get-stream populaire (plus de 5 millions de téléchargements hebdomadaires) et légère :

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

Et quelque chose comme un réducteur de flux?

Voici un exemple d'utilisation des classes ES6 comment en utiliser une.

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

Cela a fonctionné pour moi et est basé sur la documentation 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');

Bravo Sebastian J ci-dessus.

J'ai eu le "problème de tampon" avec quelques lignes de code de test que j'avais, et j'ai ajouté les informations d'encodage et cela l'a résolu, voir ci-dessous.

Démontrez le problème

Logiciel

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

contribution

hello world

production

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

Démontrez la solution

Logiciel

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

contribution

hello world

production

string hello world

Toutes les réponses répertoriées semblent ouvrir le flux lisible en mode fluide, ce qui n'est pas la valeur par défaut dans NodeJS et peut avoir des limitations car il ne prend pas en charge la contre-pression que NodeJS fournit en mode de flux lisible en pause. Voici une implémentation utilisant Just Buffers, Native Stream et Native Stream Transforms et prise en charge du mode objet

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

Que pensez-vous de ceci ?

// 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")

En utilisant le package très populairestream-buffers que vous avez probablement déjà dans les dépendances de votre projet, c'est assez simple:

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

Dans mon cas, les en-têtes de réponse du type de contenu étaient Content-Type: text / plain . Donc, j'ai lu les données de Buffer comme:

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