Sissejuhatus voogude kasutamisesse Node.js-is

Võtmed kaasavõtmiseks

• Vood rakenduses Node.js on andmetöötluse ja -edastuse põhitööriist, mistõttu on need ideaalsed reaalajas ja sündmustest juhitud rakenduste jaoks.
• Node.js-is kirjutatava voo loomiseks saate kasutada fs-mooduli funktsiooni createWriteStream(), mis kirjutab andmed kindlasse asukohta.
• Loetav, kirjutatav, dupleks ja teisendus on Node.js-i neli vootüüpi, millest igaühel on oma kasutusjuht ja funktsionaalsus.

Voog on põhiline programmeerimistööriist, mis tegeleb andmevooga. Oma tuumas kujutab voog tavaliselt baitide järjestikust ülekandmist ühest punktist teise. Node.js'i ametlik dokumentatsioon määratleb voo abstraktse liidesena, mida saate andmetega töötamiseks kasutada.

Andmete edastamine arvutis või võrgu kaudu on voogu ideaalne kasutamine.

Voogesitus Node.js-s

Vood on mänginud Node.js edus olulist rolli. Need sobivad ideaalselt reaalajas andmetöötluseks ja sündmustepõhisteks rakendusteks, mis on Node.js käituskeskkonna kaks silmapaistvat funktsiooni.

Uue voo loomiseks rakenduses Node.js peate kasutama voo API-t, mis töötab ainult stringide ja Node.js puhvri andmed. Node.js-il on nelja tüüpi vooge: kirjutatav, loetav, dupleks ja teisendus.

Kuidas luua ja kasutada kirjutatavat voogu

Kirjutatav voog võimaldab teil andmeid konkreetsesse asukohta kirjutada või saata. Moodulil fs (failisüsteem) on klass WriteStream, mida saate kasutada uue voo loomiseks fs.createWriteStream() funktsiooni. See funktsioon aktsepteerib nii faili tee, kuhu soovite andmeid kirjutada, kui ka valikuliste valikute massiivi.

const {createWriteStream} = require("fs");
(() => {
const file = "myFile.txt"; 
const myWriteStream = createWriteStream(file);
let x = 0;
const writeNumber = 10000;
const writeData = () => {
while (x < writeNumber) {
const chunk = Buffer.from(`${x}, `, "utf-8");
if (x writeNumber - 1) return myWriteStream.end(chunk); 
if (!myWriteStream.write(chunk)) break;
 x++
 }
 };
 writeData();
})();

See kood impordib createWriteStream() funktsioon, mis anonüümse noolefunktsiooni seejärel kasutab voo loomiseks, mis kirjutab andmed faili myFile.txt. Anonüümne funktsioon sisaldab sisemist funktsiooni, mida nimetatakse writeData() mis kirjutab andmeid.

The createWriteStream() funktsioon töötab koos puhvriga, et kirjutada sihtfaili numbrite kogum (0–9 999). Kui aga käivitate ülaltoodud skripti, loob see samasse kataloogi faili, mis sisaldab järgmisi andmeid:

Praegune numbrikogu lõpeb 2915-ga, kuid see oleks pidanud sisaldama numbreid kuni 9999-ni. See lahknevus tuleneb sellest, et iga WriteStream kasutab puhvrit, mis salvestab korraga kindla hulga andmeid. Et teada saada, mis see vaikeväärtus on, peate konsulteerima highWaterMark valik.

console.log("The highWaterMark value is: " +
 myWriteStream.writableHighWaterMark + " bytes.");

Ülaltoodud koodirea lisamine anonüümsele funktsioonile annab terminalis järgmise väljundi:

Terminali väljund näitab, et vaikimisi highWaterMark väärtus (mis on kohandatav) on 16 384 baiti. See tähendab, et sellesse puhvrisse saate korraga salvestada kuni 16 384 baiti andmeid. Seega tähistab kuni number 2915 (pluss kõik komad ja tühikud) maksimaalset andmemahtu, mida puhver saab korraga salvestada.

Puhvri vea lahendus on voosündmuse kasutamine. Voog puutub kokku erinevate sündmustega andmeedastusprotsessi erinevates etappides. The äravool sündmus on selle olukorra jaoks sobiv valik.

Aastal writeData() funktsiooni ülaltoodud, kõne WriteStreami write() Funktsioon tagastab väärtuse tõene, kui andmeosa (või sisemine puhver) on allpool highWaterMark väärtus. See näitab, et rakendus saab voogu rohkem andmeid saata. Kuid niipea, kui kirjuta () funktsioon tagastab false, silmus katkeb, kuna peate puhvri tühjendama.

myWriteStream.on('drain', () => {
console.log("a drain has occurred...");
 writeData();
});

Sisestades äravool ülaltoodud sündmuse kood anonüümseks funktsiooniks tühjendab WriteStreami puhver kui see on täisvõimsusel. Seejärel tuletab see meelde writeData() meetodil, et see saaks jätkata andmete kirjutamist. Värskendatud rakenduse käivitamine annab järgmise väljundi:

Pange tähele, et rakendus pidi tühjendama WriteStreami puhver kolm korda selle täitmise ajal. Tekstifailis tehti ka mõningaid muudatusi:

Kuidas luua ja kasutada loetavat voogu

Andmete lugemiseks alustage loetava voo loomisega, kasutades fs.createReadStream() funktsiooni.

const {createReadStream} = require("fs");
(() => {
const file = "myFile.txt"; 
const myReadStream = createReadStream(file);
 myReadStream.on("open", () => {
console.log(`The read stream has successfully opened ${file}.`);
 });
 myReadStream.on("data", chunk => {
console.log("The file contains the following data: " + chunk.toString());
 });
 myReadStream.on("close", () => {
console.log("The file has been successfully closed.");
 });
})();

Ülaltoodud skript kasutab looReadStream() meetod, et pääseda juurde eelmise koodiga loodud failile: myFile.txt. The looReadStream() funktsioon aktsepteerib argumentidena failitee (mis võib olla stringi, puhvri või URL-i kujul) ja mitmeid valikulisi suvandeid.

Anonüümses funktsioonis on mitu olulist voosündmust. Siiski pole märkigi sellest äravool sündmus. Selle põhjuseks on asjaolu, et loetav voog puhverdab andmeid ainult siis, kui helistate stream.push (tükk) funktsiooni või kasutage loetav sündmus.

The avatud sündmus käivitub, kui fs avab faili, millest soovite lugeda. Kui kinnitate andmeid sündmus kaudselt pidevaks vooluks, põhjustab see voo ülemineku voolavasse režiimi. See võimaldab andmetel läbida niipea, kui need muutuvad kättesaadavaks. Ülaltoodud rakenduse käivitamine annab järgmise väljundi:

Kuidas luua ja kasutada dupleksvoogu

Dupleksvoog rakendab nii kirjutatavat kui ka loetavat voo liidest, nii et saate sellist voogu lugeda ja sellele kirjutada. Üks näide on TCP-sokk, mis loob võrgumooduli.

Lihtne viis dupleksvoo omaduste demonstreerimiseks on luua andmeid edastav TCP-server ja klient.

Server.js fail

const net = require('net');
const port = 5000;
const host = '127.0.0.1';
const server = net.createServer();
server.on('connection', (socket)=> {
console.log('Connection established from client.');
 socket.on('data', (data) => {
console.log(data.toString());
 });
 socket.write("Hi client, I am server " + server.address().address);
 socket.on('close', ()=> {
console.log('the socket is closed')
 });
});
server.listen(port, host, () => {
console.log('TCP server is running on port: ' + port);
});

Klient.js fail

const net = require('net');
const client = new net.Socket();
const port = 5000;
const host = '127.0.0.1';
client.connect(port, host, ()=> {
console.log("connected to server!");
 client.write("Hi, I'm client " + client.address().address);
});
client.on('data', (data) => {
console.log(data.toString());
 client.write("Goodbye");
 client.end();
});
client.on('end', () => {
console.log('disconnected from server.');
});

Märkate, et nii serveri- kui ka kliendiskriptid kasutavad suhtlemiseks (andmete edastamiseks ja vastuvõtmiseks) loetavat ja kirjutatavat voogu. Loomulikult käivitub esmalt serverirakendus ja hakkab ühendusi kuulama. Niipea kui käivitate kliendi, loob see serveriga ühenduse kasutades TCP pordi number.

Pärast ühenduse loomist alustab klient andmeedastust, kirjutades selle abil serverisse WriteStream. Server logib saadud andmed terminali, seejärel kirjutab andmed oma WriteStreami abil. Lõpuks logib klient saadud andmed, kirjutab lisaandmed ja katkestab seejärel ühenduse serveriga. Server jääb teistele klientidele ühenduse loomiseks avatuks.

Kuidas luua ja kasutada teisendusvoogu

Teisendusvood on dupleksvood, mille väljund on sisendiga seotud, kuid sellest erinev. Node.js-il on kahte tüüpi teisendusvooge: zlib- ja krüptovood. Zlib-voog võib tekstifaili tihendada ja seejärel pärast failiedastust lahti pakkida.

Rakendus compressFile.js

const zlib = require('zlib');
const { createReadStream, createWriteStream } = require('fs');
(() => {
const source = createReadStream('myFile.txt');
const destination = createWriteStream('myFile.txt.gz');
 source.pipe(zlib.createGzip()).pipe(destination);
})();

See lihtne skript võtab algse tekstifaili, tihendab selle ja salvestab selle praegusesse kataloogi. See on lihtne protsess tänu loetavale voogudele toru () meetod. Voogkonveierid eemaldavad puhvrite kasutamise ja andmete suunamise otse ühest voost teise.

Kuid enne, kui andmed jõuavad skriptis kirjutatavasse voogu, tuleb zlib-i createGzip() meetodi kaudu teha väike põik. See meetod tihendab faili ja tagastab uue Gzip-objekti, mille kirjutusvoog seejärel vastu võtab.

Rakendus decompressFile.js

const zlib = require('zlib'); 
const { createReadStream, createWriteStream } = require('fs');
 
(() => {
const source = createReadStream('myFile.txt.gz');
const destination = createWriteStream('myFile2.txt');

 source.pipe(zlib.createUnzip()).pipe(destination);
})();

See ülaltoodud skript võtab tihendatud faili ja pakkib selle lahti. Kui avate uue minuFail2.txt faili, näete, et see sisaldab samu andmeid, mis algne fail:

Miks on vood olulised?

Vood suurendavad andmeedastuse tõhusust. Loetavad ja kirjutatavad vood on alus, mis võimaldab klientide ja serverite vahelist suhtlust, samuti suurte failide tihendamist ja edastamist.

Vood parandavad ka programmeerimiskeelte jõudlust. Ilma voogudeta muutub andmeedastusprotsess keerukamaks, nõudes arendajatelt suuremat käsitsi sisestamist ning tulemuseks on rohkem vigu ja jõudlusprobleeme.