Schreiben von node.js stream in eine String-Variable

Question

Ich hacke auf einem node.js-Programm, das SMTP-Mails erfasst und auf die Mail-Daten wirkt. Die 'smtp-protocol'-Knotenbibliothek stellt die Mail-Daten live als Stream zur Verfügung, und als node.js-Neuling bin ich mir nicht sicher, wie ich diesen Stream in eine String-Variable schreiben soll. Im Moment habe ich es mit der Linie nach stdout schreiben:

stream.pipe(process.stdout, { end : false }); 

Wie gesagt, ich brauche stattdessen ein String-Variable schreiben Diese Strom-Daten zu erhalten, die ich dann benutzen, wenn der Strom beendet ist.

Hilfe sehr geschätzt!

Answer 1

Der Schlüssel ist, diese beiden Stream events zu verwenden:

• Veranstaltung: 'data'
• Veranstaltung: 'Ende'

Für stream.on('data', ...) Sie Ihre Daten Daten entweder in einem Puffer sammeln sollte (wenn es binär ist) oder in eine Zeichenfolge.

Für on('end', ...) sollten Sie einen Rückruf mit Ihnen abgeschlossenen Puffer aufrufen, oder wenn Sie es inline und verwenden können, Rückgabe mithilfe einer Promises-Bibliothek.

Answer 2

Hoffe, das ist nützlicher als die obige Antwort (die jetzt einen defekten Link hat).

auch, dass die String-Verkettung zu beachten ist kein effizienter Weg, um die Zeichenfolge Teile zu sammeln, aber es ist der Einfachheit halber verwendet (und vielleicht auch Ihren Code kümmert sich nicht um Effizienz)

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


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

Answer 3

Von den NodeJS documentation Sie sollten dies tun - immer einen String erinnern, ohne die Codierung zu wissen, ist nur ein Haufen von 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); 
}) 

Answer 4

ich benutze in der Regel diese einfache Funktion einen Strom in einen String zu verwandeln:

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

Answer 5

Keine der oben für mich gearbeitet. Ich brauchte die Buffer-Objekt zu 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)); 
    }); 

Answer 6

Streams haben keine einfache .toString() Funktion (was ich verstehen) noch so etwas wie eine .toStringAsync(cb) Funktion (die ich nicht verstehe).

Also habe ich meine eigene Hilfsfunktion:

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

Answer 7

Das ist für mich gearbeitet 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); 
}) 

Answer 8

Was ist so etwas wie ein Strom Minderer?

Hier ist ein Beispiel mit ES6-Klassen, wie man einen verwendet.

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