Nodejs-Studiennotizen Stream module_node.js-js-Tutorial-php.cn

1, Eröffnungsanalyse

Stream ist eine abstrakte Schnittstelle, die von vielen Objekten in Node implementiert wird. Beispielsweise ist eine Anfrage an einen HTTP-Server ein Stream, und stdout ist ebenfalls ein Stream. Streams sind lesbar, beschreibbar oder beides.

Der erste Kontakt mit Stream begann in den frühen Tagen von Unix. Jahrzehntelange Praxis hat gezeigt, dass sich mit der Stream-Idee problemlos einige riesige Systeme entwickeln lassen.

In Unix wird Stream durch „|“ implementiert. Im Knoten werden als integriertes Stream-Modul viele Kernmodule und Module von Drittanbietern verwendet.

Wie bei Unix ist auch die Hauptoperation von Node Stream .pipe(). Benutzer können den Anti-Druck-Mechanismus verwenden, um das Gleichgewicht zwischen Lesen und Schreiben zu steuern.

Stream kann Entwicklern eine einheitliche Schnittstelle bieten, die wiederverwendet werden kann und das Lese- und Schreibgleichgewicht zwischen Streams über die abstrakte Stream-Schnittstelle steuern kann.

Eine TCP-Verbindung ist sowohl ein lesbarer Stream als auch ein beschreibbarer Stream, während eine HTTP-Verbindung anders ist. Ein http-Anforderungsobjekt ist ein lesbarer Stream und ein http-Antwortobjekt ein beschreibbarer Stream.

Der Stream-Übertragungsprozess wird standardmäßig in Form eines Puffers übertragen, sofern Sie keine anderen Kodierungsmethoden dafür festlegen. Das Folgende ist ein Beispiel:

Code kopieren Der Code lautet wie folgt:

var http = require('http') ;

var server = http.createServer(function(req,res){

res.writeHeader(200, {'Content-Type': 'text/plain'}) ;

res.end("Hallo, großer Bär!") ;

}) ;

server.listen(8888) ;

console.log("http-Server läuft auf Port 8888...") ;

Nach der Ausführung werden verstümmelte Zeichen angezeigt. Der Grund dafür ist, dass der angegebene Zeichensatz nicht festgelegt ist, z. B. „utf-8“.

Ändern Sie es einfach:

Code kopieren Der Code lautet wie folgt:

var http = require('http') ;

var server = http.createServer(function(req,res){

res.writeHeader(200,{

         'Content-Type' : 'text/plain;charset=utf-8' // charset=utf-8 hinzufügen

}) ;

res.end("Hallo, großer Bär!") ;

}) ;

server.listen(8888) ;

console.log("http-Server läuft auf Port 8888 ...") ;

Laufergebnis:

Warum Stream verwenden?
Die E/A im Knoten ist asynchron, daher sind zum Lesen und Schreiben auf die Festplatte und das Netzwerk Rückruffunktionen erforderlich. Das Folgende ist ein Beispiel für den Dateidownload
Obiger Code:

Code kopieren Der Code lautet wie folgt:

var http = require('http') ;

var fs = require('fs') ;

var server = http.createServer(function (req, res) {

fs.readFile(__dirname '/data.txt', function (err, data) {

           res.end(data);

}) ;

}) ;

server.listen(8888) ;

Der Code kann die erforderlichen Funktionen erfüllen, aber der Dienst muss die gesamten Dateidaten im Speicher zwischenspeichern, bevor die Dateidaten gesendet werden. Wenn die Datei „data.txt“ sehr groß ist
Wenn es groß ist und die Parallelität groß ist, wird viel Speicher verschwendet. Da der Benutzer warten muss, bis die gesamte Datei im Speicher zwischengespeichert ist, bevor er die Dateidaten akzeptiert, führt dies zu
Die Benutzererfahrung ist ziemlich schlecht. Glücklicherweise sind beide Parameter (req, res) Stream, sodass wir fs.createReadStream() anstelle von fs.readFile() verwenden können. Wie folgt:

Code kopieren Der Code lautet wie folgt:

var http = require('http') ;

var fs = require('fs') ;

var server = http.createServer(function (req, res) {

var stream = fs.createReadStream(__dirname '/data.txt') ;

Stream.pipe(res) ;

}) ;

server.listen(8888) ;

Die Methode

.pipe() hört auf die Ereignisse „data“ und „end“ von fs.createReadStream(), sodass die Datei „data.txt“ nicht vollständig zwischengespeichert werden muss
In der Datei kann unmittelbar nach Abschluss der Client-Verbindung ein Datenblock an den Client gesendet werden. Ein weiterer Vorteil der Verwendung von .pipe() besteht darin, dass das Problem gelöst werden kann, wenn der Client
Das Problem des Lese-Schreib-Ungleichgewichts wird durch eine sehr große End-to-End-Latenz verursacht.

Es gibt fünf grundlegende Streams: lesbar, beschreibbar, transformieren, duplex und „klassisch“. (Bitte überprüfen Sie die API auf spezifische Verwendung)

2. Einführung von Beispielen

Wenn die zu verarbeitenden Daten nicht gleichzeitig in den Speicher geladen werden können oder wenn es effizienter ist, sie gleichzeitig zu lesen und zu verarbeiten, müssen wir Datenströme verwenden. NodeJS stellt Operationen für Datenströme über verschiedene Streams bereit.

Am Beispiel des Programms zum Kopieren großer Dateien können wir einen schreibgeschützten Datenstrom für die Datenquelle erstellen. Das Beispiel sieht wie folgt aus:

Code kopieren Der Code lautet wie folgt:

var rs = fs.createReadStream(pathname);

rs.on('data', function (chunk) {

doSomething(chunk); // Fühlen Sie sich frei, mit den Details zu spielen

});

rs.on('end', function () {

       cleanUp() ;

}) ;

Das Datenereignis im Code wird kontinuierlich ausgelöst, unabhängig davon, ob die doSomething-Funktion damit umgehen kann. Der Code kann weiterhin wie folgt geändert werden, um dieses Problem zu lösen.

Code kopieren Der Code lautet wie folgt:

var rs = fs.createReadStream(src) ;

rs.on('data', function (chunk) {

​ rs.pause() ;

doSomething(chunk, function () {

          rs.resume() ;

}) ;

}) ;

rs.on('end', function () {

       cleanUp();

}) ;

Der doSomething-Funktion wird ein Rückruf hinzugefügt, damit wir das Lesen der Daten vor der Verarbeitung der Daten anhalten und nach der Verarbeitung der Daten mit dem Lesen der Daten fortfahren können.

Darüber hinaus können wir wie folgt auch einen schreibgeschützten Datenstrom für das Datenziel erstellen:

Code kopieren Der Code lautet wie folgt:

var rs = fs.createReadStream(src) ;

var ws = fs.createWriteStream(dst) ;

rs.on('data', function (chunk) {

            ws.write(chunk);

}) ;

rs.on('end', function () {

          ws.end();

}) ;

Nachdem doSomething durch das Schreiben von Daten in einen schreibgeschützten Datenstrom ersetzt wurde, sieht der obige Code wie ein Programm zum Kopieren von Dateien aus. Der obige Code weist jedoch das oben erwähnte Problem auf. Wenn die Schreibgeschwindigkeit nicht mit der Lesegeschwindigkeit mithalten kann, platzt der Cache im Nur-Schreib-Datenstrom. Wir können den Rückgabewert der .write-Methode verwenden, um zu bestimmen, ob die eingehenden Daten auf das Ziel geschrieben oder vorübergehend im Cache abgelegt werden, und basierend auf dem Drain-Ereignis können wir bestimmen, wann der Nur-Schreib-Datenstrom die Daten geschrieben hat Im Cache zum Ziel können die nächsten zu schreibenden Daten übergeben werden. Der Code lautet also wie folgt:

Code kopieren Der Code lautet wie folgt:

var rs = fs.createReadStream(src) ;

var ws = fs.createWriteStream(dst) ;

rs.on('data', function (chunk) {

If (ws.write(chunk) === false) {

          rs.pause() ;

}

}) ;

rs.on('end', function () {

          ws.end();

});

ws.on('drain', function () {

​ rs.resume();

}) ;

Endlich wurde die Übertragung von Daten vom schreibgeschützten Datenfluss zum schreibgeschützten Datenfluss realisiert und eine explosionsgeschützte Lagersteuerung integriert. Da es dafür viele Verwendungsszenarien gibt, wie zum Beispiel das obige Programm zum Kopieren großer Dateien, stellt NodeJS direkt die .pipe-Methode bereit, um dies zu tun, und ihre interne Implementierung ähnelt dem obigen Code.

Hier ist ein vollständigerer Vorgang zum Kopieren von Dateien:

Code kopieren Der Code lautet wie folgt:

var fs = require('fs'),

  path = require('path'),

  out =process.stdout;

var filePath = '/bb/bigbear.mkv';

var readStream = fs.createReadStream(filePath);

var writeStream = fs.createWriteStream('file.mkv');

var stat = fs.statSync(filePath);

var totalSize = stat.size;

var passiertLength = 0;

var lastSize = 0;

var startTime = Date.now();

readStream.on('data', function(chunk) {

  passedLength = chunk.length;

  if (writeStream.write(chunk) === false) {

    readStream.pause();

  }

});

readStream.on('end', function() {

  writeStream.end();

});

writeStream.on('drain', function() {

  readStream.resume();

});

setTimeout(function show() {

  var percent = Math.ceil((passedLength / totalSize) * 100);

  var size = Math.ceil(passedLength / 1000000);

  var diff = size - lastSize;

  lastSize = Größe;

  out.clearLine();

  out.cursorTo(0);

  out.write('已完成' size 'MB, ' percent '%, 速度：' diff * 2 'MB/s');

  if (passedLength < totalSize) {

    setTimeout(show, 500);

  } sonst {

    var endTime = Date.now();

    console.log();

    console.log('共用时：' (endTime - startTime) / 1000 '秒。');

  }

}, 500);