slučka udalostí v uzle js

Slucka Udalosti V Uzle Js



Node.js je výkonný rámec Javascript, ktorý umožňuje používateľom spúšťať kód Javascript na serveri mimo prehliadača. Je to neblokujúce, udalosťami riadené runtime prostredie na vytváranie spoľahlivých škálovateľných webových aplikácií. Slučka udalostí je dôležitou súčasťou Node.js, ktorá vám umožňuje vykonávať úlohy bez čakania na dokončenie jednej pred spustením ďalšej.

Aj keď je Javascript jednovláknový jazyk, Node.js dokáže priradiť úlohy operačnému systému, čo mu umožňuje spracovávať viacero úloh súčasne. Je potrebné vykonať niekoľko úloh súčasne, pretože operácie v operačnom systéme sú viacvláknové. Spätné volanie spojené s každou operáciou sa pridá do frontu udalostí a Node.js ho naplánuje tak, aby sa spustilo po dokončení zadanej úlohy.

Na písanie efektívneho a spoľahlivého kódu Node.js musí používateľ dobre rozumieť slučkám udalostí. Môže tiež pomôcť efektívne riešiť problémy s výkonom. Slučka udalostí v Node.js šetrí pamäť a umožňuje vám robiť viacero vecí naraz bez toho, aby ste museli čakať na dokončenie každej z nich. Pojem „asynchrónny“ sa vzťahuje na akúkoľvek funkciu JavaScriptu, ktorá beží na pozadí bez blokovania prichádzajúcich požiadaviek.







Skôr než prejdeme priamo na slučky udalostí, pozrime sa na rôzne aspekty programovacieho jazyka Javascript.



Javascript ako asynchrónny programovací jazyk

Poďme sa pozrieť na koncepty asynchrónneho programovania. Javascript sa používa vo webových, mobilných a desktopových aplikáciách, ale treba poznamenať, že Javascript je jednovláknový synchrónny počítačový programovací jazyk.



Na pochopenie konceptu je uvedený jednoduchý príklad kódu.





funkčná metóda 1 ( ) {

konzola. log ( 'Funkcia 1' )

}

funkčná metóda2 ( ) {

konzola. log ( 'Funkcia 2' )

}

metóda1 ( )

metóda2 ( )

V tomto kóde sa vytvoria dve jednoduché funkcie a najprv sa zavolá metóda1, takže najprv sa zaznamená metóda1 a potom sa presunie na ďalšiu.

Výkon



Javascript ako synchrónny programovací jazyk

Javascript je synchrónny programovací jazyk a vykonáva každý riadok krok za krokom, ktorý sa pohybuje zhora nadol, pričom naraz sa vykonáva iba jeden riadok. Vo vyššie uvedenom príklade kódu je metóda1 najprv zaznamenaná v termináli a potom metóda2.

Javascript ako blokovací jazyk

Keďže javascript je synchrónny jazyk, má funkciu blokovania. Nezáleží na tom, ako dlho trvá dokončenie prebiehajúceho procesu, ale nový proces sa nezačne, kým sa nedokončí predchádzajúci. Vo vyššie uvedenom príklade kódu predpokladajme, že v metóde1 je veľa skriptov kódu bez ohľadu na to, koľko času to trvá 10 sekúnd alebo minúta, metóda2 sa nespustí, kým sa nespustí celý kód v metóde1.

Používatelia to mohli zažiť pri prehliadaní. Keď sa webová aplikácia spustí v prehliadači na back-ende, vykoná sa obrovský kus kódu, takže prehliadač vyzerá, že je na nejaký čas zamrznutý, kým sa používateľovi vráti riadiaci prístup. Toto správanie je známe ako blokovanie. Prehliadač nemôže prijímať žiadne ďalšie prichádzajúce požiadavky, kým sa aktuálna požiadavka nespracuje.

Javascript je jednovláknový jazyk

Na spustenie programu v javascripte sa používa funkcia vlákna. Vlákna sú schopné vykonávať naraz iba jednu úlohu. Ostatné programovacie jazyky podporujú multi-threading a dokážu paralelne spúšťať viacero úloh, javascript obsahuje len jedno vlákno na spustenie ľubovoľného kódového skriptu.

Čakanie v Javascripte

Ako je zrejmé z názvu v tejto časti, musíme počkať na spracovanie našej žiadosti, aby sme mohli pokračovať. Čakanie môže trvať niekoľko minút, počas ktorých sa nevybavuje žiadna ďalšia požiadavka. Ak skript kódu pokračuje bez čakania, kód zaznamená chybu. Niektoré funkcie majú byť implementované v jazyku Javascript alebo konkrétnejšie Node.js, aby bol kód asynchrónny.

Teraz, keď sme pochopili rôzne aspekty Javascriptu, pochopme synchrónne a asynchrónne na niekoľkých jednoduchých príkladoch.

Synchrónne vykonávanie kódu v Javascripte

Synchrónny znamená, že kód sa vykonáva sekvenčne alebo jednoduchšie krok za krokom, začínajúc zhora a posúvajúc sa nadol po riadkoch.

Nižšie je uvedený príklad, ktorý vám môže pomôcť pochopiť:

// application.js

konzoly. log ( 'jeden' )

konzoly. log ( 'Dva' )

konzoly. log ( 'tri' )

V tomto kóde sú tri príkazy console.log, z ktorých každý niečo vypíše. Najprv sa prvý príkaz, ktorý vytlačí „Jedna“ v konzole, odošle do zásobníka hovorov na 1 ms (odhad), potom sa prihlási do terminálu. Potom sa druhý príkaz vloží do zásobníka hovorov a teraz je čas 2 ms s jedným pridaným z predchádzajúceho a potom sa do konzoly prihlási „Dva“. Nakoniec sa posledný príkaz vloží do zásobníka hovorov, zatiaľ čo čas je 3 ms a do konzoly sa zapíše „Tri“.

Vyššie uvedený kód je možné spustiť vyvolaním nasledujúceho príkazu:

aplikácia uzla. js

Výkon

Fungovanie je podrobne vysvetlené vyššie a pri jeho zohľadnení sa výstup prihlási do konzoly mihnutím oka:

Asynchrónne vykonávanie kódu v Javascripte

Teraz poďme zrefaktorovať rovnaký kód zavedením spätných volaní a vytvorením asynchrónneho kódu. Vyššie uvedený kód môže byť refaktorovaný ako:

// application.js
funkcia printOne ( zavolaj späť ) {
setTimeout ( funkciu ( ) {
konzoly. log ( 'jedna' ) ;
zavolaj späť ( ) ;
} , 1000 ) ;
}
funkcia printTwo ( zavolaj späť ) {
setTimeout ( funkciu ( ) {
konzoly. log ( 'Dva' ) ;
zavolaj späť ( ) ;
} , 2000 ) ;
}
funkcia printTri ( ) {
setTimeout ( funkciu ( ) {
konzoly. log ( 'tri' ) ;
} , 3000 ) ;
}
konzoly. log ( 'Začiatok programu' ) ;
printOne ( funkciu ( ) {
tlačDva ( funkciu ( ) {
vytlačiťTri ( ) ;
} ) ;
} ) ;
konzoly. log ( 'Koniec programu' ) ;

V tomto kóde vyššie:

  • Tri funkcie sú deklarované na tlač „Jedna“, „Dva“ a „Tri“, každá funkcia má parameter spätného volania, ktorý umožňuje sekvenčné vykonávanie kódu.
  • Časový limit sa nastavuje pomocou funkcie setTimeout a existuje príkaz console.log na tlač po určitom oneskorení.
  • Vytlačia sa dve správy „Začiatok programu“ a „Koniec programu“, ktoré označujú začiatok a koniec programu.
  • Program sa spustí vytlačením „Start of the Program“, po ktorom sa s 1-sekundovým oneskorením vykoná funkcia printOne, potom sa s 2-sekundovým oneskorením vykoná funkcia printTwo a nakoniec sa s 3-sekundovým oneskorením vykoná funkcia printThree. meškanie.
  • Program nečaká na vykonanie asynchrónneho kódu vo funkciách setTimeouts, ktoré zaznamenajú príkaz „Koniec programu“ pred vytlačením Jednotky, Dvojky a Trojky.

Výkon

Spustite vyššie uvedený kód vykonaním tohto príkazu v termináli:

aplikácia uzla. js

Teraz by sa výstup v termináli zobrazoval asynchrónne ako:

Teraz, keď úplne rozumieme synchrónnemu a asynchrónnemu vykonávaniu, prejdime k upevneniu nášho konceptu slučky udalostí v Node.js.

Node.js: Mechanizmus slučky udalostí

Vykonávanie synchrónnych aj asynchrónnych úloh je riadené slučkou udalostí v Node.js. Vykonanie je vyvolané hneď po spustení projektu Node.js a plynulo prenáša zložité úlohy do systému. To zaisťuje, že ostatné úlohy môžu v hlavnom vlákne bežať hladko.

Vizuálne vysvetlenie slučky udalostí v Node.js

Slučka udalostí je v Node.js nepretržitá a polonekonečná. Slučka udalostí je vyvolaná spustením skriptu kódu Node.js a je zodpovedná za uskutočňovanie asynchrónnych volaní API a volanie procesov. Tick() a plánovanie časovačov potom obnoví vykonávanie slučky udalostí.

V Node.js spracováva spätné volania päť hlavných typov frontov:

  • Za spracovanie spätných volaní spojených s „setTimeout“ a „setInterval“ je zodpovedná „Časovačová fronta“ bežne známa ako min-hromada.
  • Spätné volania pre asynchrónne operácie ako v moduloch „fs“ a „http“ sú spracované pomocou „I/O Queue“.
  • „Check Queue“ obsahuje spätné volania pre funkciu „setImmediate“, ktorá je jedinečná pre Node.
  • „Zatvoriť front“ spravuje spätné volania spojené s udalosťou ukončenia akejkoľvek asynchrónnej úlohy.
  • Nakoniec, vo fronte „Micro Task“ sú dva rôzne fronty:
    • Front „nextTick“ obsahuje spätné volania spojené s funkciou „process.nextTick“.
    • Front „Promise“ riadi spätné volania súvisiace s natívnym Promise.

Funkcia Event Loop v Node.js

Slučka udalostí funguje podľa špecifických požiadaviek, ktoré riadia príkaz na vykonanie spätného volania. Synchrónny kód Javascript používateľa má prioritu na začiatku procesu, takže slučka udalostí sa spustí až po vymazaní zásobníka hovorov. Nasledujúca postupnosť vykonávania sa riadi štruktúrovaným vzorom:

Najvyššiu prioritu majú spätné volania vo fronte mikroúloh, potom sa presunú na vykonanie úloh vo fronte nextTick, po ktorých nasledujú úlohy vo fronte Promise. Potom sa spracujú procesy v spätných volaniach vo fronte časovača, po ktorých sa po každom spätnom volaní časovača znova navštívi front mikroúloh. Spätné volania vo frontoch I/O, kontrolných a uzatváracích frontoch sa potom vykonávajú podobným spôsobom ako front mikroúloh navštívených po každej fáze.

Cyklus pokračuje vo vykonávaní, ak existuje viac spätných volaní na spracovanie. Keď sa skript kódu skončí alebo nezostanú žiadne spätné volania na spracovanie, slučka udalostí sa efektívne ukončí.

Teraz, keď hlboko rozumieme slučke udalostí, pozrime sa na jej funkcie.

Vlastnosti slučky udalostí v Node.js

Hlavné funkcie sú:

  • Slučka udalostí je nekonečná slučka a pokračuje vo vykonávaní úloh hneď, ako ich dostane, a prejde do režimu spánku v prípade, že neexistujú žiadne úlohy, ale začne fungovať hneď po prijatí úlohy.
  • Úlohy vo fronte udalostí sa vykonajú iba vtedy, keď je zásobník prázdny, čo znamená, že nie je aktívna žiadna operácia.
  • Spätné volania a prísľuby možno použiť v slučke udalostí.
  • Keďže sa slučka udalostí riadi princípom fronty abstraktných údajov, splní prvú úlohu a potom prejde na ďalšiu.

Po dôkladnom pochopení slučky udalostí a logiky asynchrónneho a synchrónneho vykonávania môže pochopenie rôznych fáz upevniť koncepciu slučky udalostí.

Node.js Fázy cyklu udalostí

Ako bolo uvedené vyššie, slučka udalostí je polonekonečná. Má veľa fáz, ale niektoré fázy sa používajú na vnútornú manipuláciu. Tieto fázy nemajú žiadny vplyv na skript kódu.

Slučka udalostí sleduje funkčnosť frontu a vykonáva úlohu na princípe prvý dovnútra a prvý von. Naplánované časovače bude spracovávať operačný systém, kým nevyprší ich platnosť. Časovače s uplynutou platnosťou sa potom pridajú do frontu spätných volaní pre časovače.

Slučka udalostí vykonáva úlohy vo fronte časovača jednu po druhej, kým nezostanú žiadne ďalšie úlohy alebo kým nedosiahne maximálny povolený počet úloh. V nižšie uvedených častiach sú vysvetlené hlavné fázy slučiek udalostí.

Fáza časovačov

V Node.js je časovač API, ktorý dokáže naplánovať funkcie, ktoré sa majú vykonať v budúcnosti. Po uplynutí prideleného času sa spätné volanie časovača vykoná hneď, ako ich bude možné naplánovať; môže však nastať oneskorenie buď zo strany operačného systému, alebo z dôvodu vykonania iných spätných volaní.

API časovačov má tri hlavné funkcie:

  • setTimeout
  • setImmediate
  • setInterval

Vyššie uvedené funkcie sú synchrónne. Fáza časovača v slučke udalostí má svoj rozsah obmedzený na funkcie setTimeout a setInterval. Zatiaľ čo funkcia kontroly spracováva funkciu setImmediate.

Uvažujme jednoduchý príklad na upevnenie teoretickej časti:

// application.js

funkcia oneskorenáFunkcia ( ) {

konzoly. log ( 'funkcia oneskorenia sa vykoná po uplynutí časového limitu' ) ;

}

konzoly. log ( 'Začiatok programu' ) ;

setTimeout ( oneskorená funkcia, 2000 ) ;

konzoly. log ( 'Koniec programu' ) ;

V tomto kóde:

  • Program sa spustí prihlásením príkazu „Štart programu“ do terminálu.
  • Potom sa zavolá delayedFunction s časovačom 2 ms, kódový skript sa nezastaví a pokračuje v ďalšej manipulácii s oneskorením na pozadí.
  • Výpis „Koniec programu sa zaprotokoluje po prvom vyhlásení.
  • Po oneskorení 2 ms sa výpis v oneskorenejFunkcii prihlási do terminálu.

Výkon

Výstup sa zobrazí ako:

Je vidieť, že kód nie je zastavený, aby ho delayedFunction spracoval; posunie sa dopredu a po oneskorení sa spracuje spätné volanie funkcie.

Čakajúce spätné volania

Slučka udalostí kontroluje udalosti, ktoré sa dejú, ako je čítanie súborov, sieťové aktivity alebo vstupné/výstupné úlohy vo fáze dotazovania. Je dôležité vedieť, že v Node.js sa v tejto fáze prieskumu spracúvajú iba niektoré udalosti. Pri následnej iterácii slučky udalostí však môžu byť určité udalosti odložené do čakajúcej fázy. Toto je kľúčový koncept, ktorý treba mať na pamäti pri optimalizácii a odstraňovaní problémov s kódom Node.js, ktorý zahŕňa zložité operácie riadené udalosťami.

Je dôležité pochopiť, že počas fázy čakania spätných volaní slučka udalostí pridáva odložené udalosti do frontu čakajúcich spätných volaní a vykonáva ich. Táto fáza tiež spracováva niektoré chyby soketov TCP, ktoré systém vygeneroval, ako napríklad chybové udalosti ECONNREFUSED v určitých operačných systémoch.

Nižšie je uvedený príklad na upevnenie konceptu:

// application.js
konšt fs = vyžadovať ( 'fs' ) ;
funkcia readFileAsync ( filePath, spätné volanie ) {
fs. readFile ( './PromiseText.txt' , 'utf8' , funkcia ( chyba, údaje ) {
ak ( chybovať ) {
konzoly. chyba ( ` Chyba čítanie súboru : $ { chybovať správu } ` ) ;
} inak {
konzoly. log ( ` Súbor obsahu : $ { údajov } ` ) ;
}
zavolaj späť ( ) ;
} ) ;
}
konzoly. log ( 'Začiatok programu' ) ;
readFileAsync ( './PromiseText.txt' , funkcia ( ) {
konzoly. log ( 'Spätné volanie čítania súboru uskutočnené' ) ;
} ) ;
konzoly. log ( 'Koniec programu' ) ;

V tomto kóde:

  • Program sa spúšťa prihlásením príkazu „Štart programu“ do terminálu.
  • ReadFileAsync je definovaný asynchrónne na čítanie obsahu súboru „PromiseText.txt“. Je to parametrizovaná funkcia, ktorá po prečítaní súboru vykoná funkciu spätného volania.
  • Funkcia readFileAsync sa volá na spustenie procesu čítania súboru.
  • V procese čítania súboru sa program nezastaví; namiesto toho prejde na ďalší príkaz a prihlási ho do terminálu „Koniec programu“.
  • Asynchrónna udalosť čítania súboru je spracovaná na pozadí slučkou udalostí.
  • Po asynchrónnom prečítaní súboru a prihlásení obsahu do terminálu program prihlási obsah súboru do terminálu. Potom zaznamená nasledujúcu správu „Spätné volanie prečítaného súboru bolo vykonané“.
  • Slučka udalostí spracováva čakajúce operácie spätného volania v ďalšej fáze.

Výkon

Výsledkom vyššie uvedeného vykonania je:

Nečinnosť, prípravná fáza v Node.js

Nečinná fáza sa používa na riešenie interných funkcií v Node.js, takže nejde o štandardnú fázu. Nemá vplyv na skript kódu. Fáza nečinnosti je ako prestávka pre slučku udalostí, počas ktorej sa na pozadí riadia úlohy s nízkou prioritou. Jednoduchý príklad na pochopenie tejto fázy je:

konšt { nečinný } = vyžadovať ( 'idle-gc' ) ;

nečinný. ignorovať ( ) ;

V tomto kóde sa používa modul „idle-gc“, ktorý umožňuje ignorovať fázu nečinnosti. Slúži na riešenie situácií, keď je slučka udalostí zaneprázdnená a úlohy na pozadí sa nevykonávajú. Použitie idle.ignore sa nepovažuje za optimálne, pretože môže spôsobiť problémy s výkonom.

Fáza hlasovania v Node.js

Fáza prieskumu v Node.js slúži ako:

  • Zaoberá sa udalosťami vo fronte hlasovania a vykonáva príslušné úlohy.
  • Rozhoduje, koľko času strávite čakaním a kontrolou I/O operácií v procese.

Keď slučka udalostí vstúpi do fázy hlasovania kvôli absencii časovača, vykoná sa jedna z nižšie uvedených úloh:

  • Vo fáze dotazovania slučky udalostí v Node.js sú čakajúce I/O udalosti zaradené do frontu a potom vykonávané v sekvenčnej procedúre podľa princípu First In a First Out, kým sa front nevyprázdni. Počas vykonávania spätných volaní sú v činnosti aj fronty nextTick a mikroúloh. To zaisťuje plynulosť a umožňuje efektívnejšie a spoľahlivejšie zvládať I/O operácie.
  • Ak je front prázdny a skript nebol naplánovaný funkciou setImmediate(), cyklus udalostí sa ukončí a prejde do ďalšej fázy (kontrola). Na druhej strane, ak sa plánovanie skriptu vykonalo pomocou funkcie setImmediate(), slučka udalostí umožňuje pridanie spätných volaní do frontu, ktoré vykoná.

Najlepšie to ilustruje jednoduchý príklad kódu:

setTimeout ( ( ) => {

konzoly. log ( 'Asynchrónna operácia dokončená' ) ;

} , 2000 ) ;

konzoly. log ( 'Štart' ) ;

setImmediate ( ( ) => {

konzoly. log ( 'setImmediate callback vykonaný' ) ;

} ) ;

konzoly. log ( 'Koniec' ) ;

V tomto kóde:

  • Dve správy „Štart“ a „Koniec“ označujú spustenie a ukončenie programu.
  • Funkcia setTimeout() nastaví funkciu spätného volania s oneskorením 2 ms a prihlási do terminálu „Asynchrónna operácia dokončená“.
  • Funkcia setImmediate() zaznamená do terminálu správu „setImmediate callback zrealizovaná“ po prihlásení správy Štart do terminálu.

Výkon

Na výstupe by sa správy zobrazili len s minútovým pozorovaním, že „Asynchrónna operácia dokončená“ si vyžaduje čas a vytlačí sa po správe „Koniec“:

Fáza kontroly Node.js

Po vykonaní fázy dopytovania sa vykonajú spätné volania vo fáze kontroly. Ak je kódový skript naplánovaný pomocou funkcie setImmediate() a funkcia poll je voľná, slučka udalostí funguje tak, že sa presunie priamo do fázy kontroly namiesto nečinnosti. Funkcia setImmediate() je jedinečný časovač, ktorý funguje počas rôznych fáz slučky udalostí.

Rozhranie libuv API sa používa na plánovanie vykonania spätného volania po dokončení fázy poll. Počas vykonávania kódu sa slučka udalostí dostane do fázy dopytovania, v ktorej čaká na prichádzajúce požiadavky na pripojenie. V inom prípade, ak je spätné volanie naplánované pomocou funkcie setImmediate() a fáza dotazovania je ukončená bez akejkoľvek aktivity, namiesto čakania sa presunie do fázy kontroly. Pre pochopenie zvážte nasledujúci príklad:

// application.js

konzoly. log ( 'Štart' ) ;

setImmediate ( ( ) => {

konzoly. log ( 'Okamžité spätné volanie' ) ;

} ) ;

konzoly. log ( 'Koniec' ) ;

V tomto kóde sú do terminálu prihlásené tri správy. Funkcia setImmediate() potom nakoniec odošle spätné volanie na zaprotokolovanie správy “ Okamžité spätné volanie “ do terminálu.

Výkon

Výstup vyššie uvedeného kódu sa zobrazí v nasledujúcom poradí:

Node.js zatvorí spätné volania

Node.js používa túto fázu uzavretia na spustenie spätných volaní na uzavretie udalostí a ukončenie iterácie slučky udalostí. Po uzavretí spojenia slučka udalostí v tejto fáze spracováva udalosti zatvorenia. V tejto fáze cyklu udalostí sa generujú a spracovávajú „nextTick()“ a mikroúlohy podobne ako v iných fázach.

Funkcia process.exit sa používa na ukončenie slučky udalostí v každom okamihu. Slučka udalostí bude ignorovať všetky čakajúce asynchrónne operácie a proces Node.js sa ukončí.

Jednoduchý príklad na zváženie je:

// application.js
konšt net = vyžadovať ( 'net' ) ;
konšt server = net. createServer ( ( zásuvka ) => {
zásuvka. na ( 'Zavrieť' , ( ) => {
konzoly. log ( 'Zásuvka uzavretá' ) ;
} ) ;
zásuvka. na ( 'data' , ( údajov ) => {
konzoly. log ( 'Prijaté údaje:' , údaje. natiahnuť ( ) ) ;
} ) ;
} ) ;
server. na ( 'Zavrieť' , ( ) => {
konzoly. log ( 'Server uzavretý' ) ;
} ) ;
konšt prístav = 3000 ;
server. počúvaj ( prístav, ( ) => {
konzoly. log ( `Server počúva na porte $ { prístav } ` ) ;
} ) ;
setTimeout ( ( ) => {
konzoly. log ( „Zatváranie servera po 10 sekundách“ ) ;
server. Zavrieť ( ) ;
proces. VÝCHOD ( ) ;
} , 10 000 ) ;

V tomto kóde:

  • const net = vyžadovať(‘net’) “importuje sieťový modul potrebný na obsluhu TCP servera a “ const server = net.createServer((socket) => { ” vytvorí novú inštanciu servera TCP.
  • socket.on(‘zavrieť’, () => {… } “ počúva „zatvorenie“ na všetkých zásuvkách. Keď je pripojenie zásuvky uzavreté, na termináli sa zaznamená správa „Socket Closed“.
  • socket.on(‘data’, (data) => {} ” skontroluje prichádzajúce dáta zo všetkých jednotlivých soketov a vytlačí ich pomocou funkcie “.toString()”.
  • server.on(‘zavrieť’, () => {…} ” skontroluje udalosť „close“ na samotnom serveri a keď sa spojenie so serverom uzavrie, zaznamená do terminálu správu „Server Closed“.
  • server.listen(port, () => {…} ” počúva prichádzajúce spojenia na porte.
  • setTimeout(() => {…} ” nastaví časovač na 10 ms na zatvorenie servera.

Tým sa končí diskusia o rôznych fázach slučky udalostí v Node.js. Predtým, ako prejdeme k záveru, prediskutujeme poslednú vec, a to ako ukončiť slučku udalostí v Node.js.

Ukončenie slučky udalostí v Node.js

Slučka udalostí je vo fáze vykonávania, pokiaľ sú vo všetkých radoch fáz slučky udalostí nejaké úlohy. Slučka udalostí sa skončí po vydaní výstupnej fázy a spätné volanie výstupného poslucháča sa vráti, ak nie sú vo frontoch žiadne ďalšie úlohy.

Explicitným spôsobom ukončenia slučky udalostí je použitie metódy „.exit“. Aktívne procesy v Node.js sa okamžite ukončia, akonáhle sa zavolá funkcia process.exit. Všetky naplánované a čakajúce udalosti budú zrušené:

proces. na ( 'VÝCHOD' , ( kód ) => {

konzoly. log ( `Ukončenie s výstupným kódom : $ { kód } ` ) ;

} ) ;

proces. VÝCHOD ( 1 ) ;

Používatelia môžu počúvať funkciu .exit. Je potrebné poznamenať, že funkcia „.exit“ musí byť synchrónna, pretože program Node.js sa ukončí hneď, ako si vypočuje túto udalosť.

Týmto sa diskusia o slučke udalostí končí. Podrobný článok, ktorý obsahuje všetky koncepty, fázy a príklady súvisiace so slučkou udalostí.

Záver

Pred pochopením slučky udalostí môže prehľad synchrónnych a asynchrónnych konceptov pomôcť pochopiť tok kódu v slučke udalostí. Synchrónne vykonávanie znamená vykonávanie krok za krokom, zatiaľ čo asynchrónne vykonávanie znamená zastavenie niektorých krokov bez čakania na ich dokončenie. Fungovanie slučky udalostí spolu so všetkými fázami spolu s vhodnými príkladmi je diskutované v článku.