Ich hacke ein Knotenprogramm, mit smtp-protocoldem SMTP-E-Mails erfasst und auf die E-Mail-Daten reagiert werden. Die Bibliothek stellt die E-Mail-Daten als Stream bereit, und ich weiß nicht, wie ich das in eine Zeichenfolge umwandeln soll.

Ich schreibe es gerade, um mit stdout zu arbeiten stream.pipe(process.stdout, { end: false }), aber wie gesagt, ich brauche stattdessen die Stream-Daten in einer Zeichenfolge, die ich verwenden kann, sobald der Stream beendet ist.

Wie sammle ich alle Daten aus einem Node.js-Stream in einer Zeichenfolge?

(Diese Antwort stammt aus der Zeit vor Jahren, als es die beste Antwort war. Darunter befindet sich jetzt eine bessere Antwort. Ich habe mit node.js nicht Schritt gehalten und kann diese Antwort nicht löschen, da sie bei dieser Frage als "richtig" markiert ist ". Wenn Sie daran denken, nach unten zu klicken, was soll ich dann tun?)

Der Schlüssel besteht darin, die dataund -Ereignisseend eines lesbaren Streams zu verwenden . Hören Sie sich diese Ereignisse an:

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

Wenn Sie das dataEreignis erhalten, fügen Sie den neuen Datenblock einem Puffer hinzu, der zum Sammeln der Daten erstellt wurde.

Wenn Sie das endEreignis erhalten, konvertieren Sie gegebenenfalls den fertigen Puffer in eine Zeichenfolge. Dann tun Sie, was Sie damit tun müssen.

Eine andere Möglichkeit wäre, den Stream in ein Versprechen umzuwandeln (siehe Beispiel unten) und den aufgelösten Wert mit then(oder await) einer Variablen zuzuweisen.

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)

Keines der oben genannten hat bei mir funktioniert. Ich musste das Buffer-Objekt verwenden:

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

Hoffe das ist nützlicher als die obige Antwort:

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

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

Beachten Sie, dass die Verkettung von Zeichenfolgen nicht die effizienteste Methode zum Sammeln der Zeichenfolgenteile ist, sondern der Einfachheit halber verwendet wird (und Ihr Code kümmert sich möglicherweise nicht um die Effizienz).

Dieser Code kann auch zu unvorhersehbaren Fehlern bei Nicht-ASCII-Text führen (es wird davon ausgegangen, dass jedes Zeichen in ein Byte passt), aber das interessiert Sie vielleicht auch nicht.

Normalerweise verwende ich diese einfache Funktion, um einen Stream in einen String umzuwandeln:

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

Anwendungsbeispiel:

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

Und noch eine für Streicher, die Versprechen verwenden:

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

Verwendung:

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

Entfernen Sie .toString()bei Bedarf die zur Verwendung mit Binärdaten zu verwendenden.

Update : @AndreiLED hat richtig darauf hingewiesen, dass dies Probleme mit Strings hat. Ich konnte mit der Version des Knotens, die ich habe, keinen Stream zurückgeben, der Zeichenfolgen zurückgibt , aber die API stellt fest, dass dies möglich ist.

In der Dokumentation zu nodejs sollten Sie dies tun - denken Sie immer an eine Zeichenfolge, ohne zu wissen, dass die Codierung nur ein Bündel von Bytes ist:

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 haben weder eine einfache .toString()Funktion (die ich verstehe) noch so etwas wie eine .toStringAsync(cb)Funktion (die ich nicht verstehe).

Also habe ich meine eigene Hilfsfunktion erstellt:

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

Ich hatte mehr Glück damit:

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

Ich benutze Node v9.11.1und das readstreamist die Antwort von einem http.getRückruf.

Die sauberste Lösung könnte darin bestehen, das Paket "string-stream" zu verwenden, das einen Stream mit einem Versprechen in einen String konvertiert.

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

Einfacher Weg mit der beliebten (über 5 Millionen wöchentliche Downloads) und leichten Get-Stream- Bibliothek:

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

Was ist mit so etwas wie einem Stromreduzierer?

Hier ist ein Beispiel für die Verwendung von ES6-Klassen.

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

Dies hat bei mir funktioniert und basiert auf Node v6.7.0 docs :

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

Gut gemacht Sebastian J oben.

Ich hatte das "Pufferproblem" mit ein paar Zeilen Testcode, die ich hatte, und fügte die Codierungsinformationen hinzu und es löste es, siehe unten.

Demonstrieren Sie das Problem

Software

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

Eingang

hello world

Ausgabe

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

Demonstrieren Sie die Lösung

Software

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

Eingang

hello world

Ausgabe

string hello world

Alle aufgelisteten Antworten scheinen den lesbaren Stream im fließenden Modus zu öffnen, was in NodeJS nicht die Standardeinstellung ist und Einschränkungen aufweisen kann, da NodeJS im angehaltenen lesbaren Stream-Modus keine Unterstützung für den Gegendruck bietet. Hier ist eine Implementierung mit Just Buffers, Native Stream und Native Stream Transforms und Unterstützung für den Objektmodus

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

Mit dem sehr beliebten stream-buffersPaket, das Sie wahrscheinlich bereits in Ihren Projektabhängigkeiten haben, ist dies ziemlich einfach:

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

In meinem Fall lautete der Inhaltstyp der Antwortheader Inhaltstyp: Text / Klartext . Also habe ich die Daten von Buffer wie folgt gelesen:

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