zanka dogodkov v vozlišču js

Zanka Dogodkov V Vozliscu Js



Node.js je zmogljivo ogrodje Javascript, ki uporabnikom omogoča izvajanje kode Javascript na strežniku zunaj brskalnika. Je neblokirno izvajalno okolje, ki ga vodijo dogodki, za gradnjo zanesljivih razširljivih spletnih aplikacij. Zanka dogodkov je pomemben del Node.js, ki vam omogoča izvajanje nalog, ne da bi čakali, da se ena konča, preden začnete z drugo.

Čeprav je Javascript jezik z eno nitjo, lahko Node.js operacijskemu sistemu dodeli naloge, kar mu omogoča obdelavo več nalog hkrati. Opraviti je treba več nalog hkrati, ker so operacije v operacijskem sistemu večnitne. Povratni klic, povezan z vsako operacijo, je dodan v čakalno vrsto dogodkov in Node.js ga načrtuje za zagon, ko je navedena naloga končana.

Za pisanje učinkovite in zanesljive kode Node.js mora uporabnik dobro razumeti zanke dogodkov. Pomaga lahko tudi pri učinkovitem odpravljanju težav z zmogljivostjo. Zanka dogodkov v Node.js prihrani pomnilnik in vam omogoča, da naredite več stvari hkrati, ne da bi morali čakati, da se vsaka konča. Izraz 'asinhroni' se nanaša na katero koli funkcijo Javascript, ki deluje v ozadju, ne da bi blokirala dohodne zahteve.







Preden skočimo neposredno na zanke dogodkov, si poglejmo različne vidike programskega jezika Javascript.



Javascript kot asinhroni programski jezik

Oglejmo si koncepte asinhronega programiranja. Javascript se uporablja v spletnih, mobilnih in namiznih aplikacijah, vendar je treba upoštevati, da je Javascript sinhroni računalniški programski jezik z eno nitjo.



Za razumevanje koncepta je podan preprost primer kode.





metoda funkcije1 ( ) {

konzola. dnevnik ( 'Funkcija 1' )

}

metoda funkcije2 ( ) {

konzola. dnevnik ( 'Funkcija 2' )

}

metoda1 ( )

metoda2 ( )

V tej kodi sta ustvarjeni dve preprosti funkciji in najprej se pokliče metoda1, da bi najprej zabeležila metodo1 in se nato premaknila na naslednjo.

Izhod



Javascript kot sinhroni programski jezik

Javascript je sinhroni programski jezik in izvede vsako vrstico korak za korakom od zgoraj navzdol, pri čemer se hkrati izvaja samo ena vrstica. V zgornjem primeru kode se metoda1 najprej zabeleži v terminal in nato metoda2.

Javascript kot jezik za blokiranje

Ker je javascript sinhroni jezik, ima funkcijo blokiranja. Ni pomembno, koliko časa traja dokončanje tekočega procesa, vendar se nov postopek ne bo začel, dokler ni končan prejšnji. V zgornjem primeru kode predpostavimo, da je v metodi1 veliko skripta kode, ne glede na to, koliko časa traja, 10 sekund ali minuta, metoda2 ne bo izvedena, dokler ni izvedena vsa koda v metodi1.

Uporabniki so to morda doživeli med brskanjem. Ko se spletna aplikacija izvaja v brskalniku v ozadju, se izvaja ogromen kos kode, tako da se zdi, da je brskalnik nekaj časa zamrznjen, preden uporabniku vrne nadzorni dostop. To vedenje je znano kot blokiranje. Brskalnik ne more sprejeti nobenih nadaljnjih dohodnih zahtev, dokler trenutna zahteva ni obdelana.

Javascript je jezik z eno nitjo

Za zagon programa v javascriptu se uporablja funkcija niti. Niti lahko izvajajo samo eno nalogo naenkrat. Drugi programski jeziki podpirajo večnitnost in lahko izvajajo več nalog vzporedno, javascript vsebuje samo eno nit za izvajanje katerega koli kodnega skripta.

Čakanje v Javascriptu

Kot je razvidno iz imena v tem razdelku, moramo za nadaljevanje počakati na obdelavo naše zahteve. Čakanje lahko traja nekaj minut, med katerimi se ne upošteva nobena nadaljnja zahteva. Če se skript kode nadaljuje brez čakanja, bo koda naletela na napako. Nekatere funkcionalnosti je treba implementirati v Javascript ali natančneje v Node.js, da bo koda asinhrona.

Zdaj, ko smo razumeli različne vidike Javascripta, poglejmo sinhrono in asinhrono na nekaj preprostih primerih.

Sinhrono izvajanje kode v Javascriptu

Sinhrono pomeni, da se koda izvaja zaporedno ali preprosteje korak za korakom, začenši od vrha in navzdol po vrsticah.

Spodaj je podan primer, ki lahko pomaga razumeti:

// aplikacija.js

konzola. dnevnik ( 'ena' )

konzola. dnevnik ( 'dva' )

konzola. dnevnik ( 'tri' )

V tej kodi so trije stavki console.log, od katerih vsak nekaj natisne. Najprej se prvi stavek, ki bo v konzoli natisnil »One«, pošlje v klicni sklad za 1 ms (ocenjeno), nato pa se zabeleži v terminal. Po tem je drugi stavek potisnjen v sklad klicev in zdaj je čas 2 ms z enim, ki je dodan iz prejšnjega, nato pa na konzolo zapiše »Dva«. Končno je zadnji stavek potisnjen v sklad klicev, saj je zdaj čas 3 ms in v konzolo zabeleži »Tri«.

Zgornjo kodo je mogoče izvesti s klicem naslednjega ukaza:

aplikacija vozlišča. js

Izhod

Delovanje je zgoraj podrobno razloženo in če ga upoštevamo, se izhod prijavi v konzolo, kot bi mignil:

Asinhrono izvajanje kode v Javascriptu

Zdaj preoblikujemo isto kodo tako, da uvedemo povratne klice in naredimo kodo asinhrono. Zgornjo kodo je mogoče predelati kot:

// aplikacija.js
funkcija printOne ( poklicati nazaj ) {
setTimeout ( funkcijo ( ) {
konzola. dnevnik ( 'ena' ) ;
poklicati nazaj ( ) ;
} , 1000 ) ;
}
funkcija printTwo ( poklicati nazaj ) {
setTimeout ( funkcijo ( ) {
konzola. dnevnik ( 'dva' ) ;
poklicati nazaj ( ) ;
} , 2000 ) ;
}
funkcija printThree ( ) {
setTimeout ( funkcijo ( ) {
konzola. dnevnik ( 'Tri' ) ;
} , 3000 ) ;
}
konzola. dnevnik ( 'Začetek programa' ) ;
printOne ( funkcijo ( ) {
printTwo ( funkcijo ( ) {
natisniTri ( ) ;
} ) ;
} ) ;
konzola. dnevnik ( 'Konec programa' ) ;

V tej zgornji kodi:

  • Tri funkcije so deklarirane za izpis »One«, »Two« in »Three«, vsaka funkcija ima parameter povratnega klica, ki omogoča zaporedno izvajanje kode.
  • Časovna omejitev se nastavi s funkcijo setTimeout in obstaja stavek console.log za tiskanje po določeni zakasnitvi.
  • Natisnjeni sta dve sporočili »Začetek programa« in »Konec programa«, ki označujeta začetek in konec programa.
  • Program se začne s tiskanjem »Začetek programa«, nato se funkcija printOne izvede z 1-sekundnim zamikom, nato se funkcija printTwo izvede z 2-sekundnim zamikom in končno se izvede funkcija printThree s 3-sekundnim zamikom. zamuda.
  • Program ne čaka na izvajanje asinhrone kode znotraj funkcij setTimeouts, ki zabeležijo stavek »Konec programa«, preden natisnejo One, Two in Three.

Izhod

Zaženite zgornjo kodo tako, da v terminalu izvedete ta ukaz:

aplikacija vozlišča. js

Zdaj bi se izhod v terminalu prikazal asinhrono kot:

Zdaj, ko popolnoma razumemo sinhrono in asinhrono izvajanje, pojdimo utrditi naš koncept zanke dogodkov v Node.js.

Node.js: mehanizem zanke dogodkov

Izvajanje tako sinhronih kot asinhronih nalog upravlja zanka dogodkov v Node.js. Izvedba se prikliče takoj, ko je projekt Node.js zagnan in gladko prenese zapletene naloge v sistem. To zagotavlja nemoteno izvajanje drugih nalog v glavni niti.

Vizualna razlaga zanke dogodkov v Node.js

Dogodkovna zanka je v Node.js neprekinjena in pol neskončna. Dogodkovna zanka se prikliče z začetkom skripta kode Node.js in je odgovorna za izvajanje asinhronih klicev API-ja in klicanje procesov. Tick(), časovniki za razporejanje pa nato nadaljujejo z izvajanjem dogodkovne zanke.

V Node.js pet glavnih vrst čakalnih vrst obravnava povratne klice:

  • »Čakalna vrsta časovnika«, splošno znana kot min-heap, je odgovorna za obravnavanje povratnih klicev, povezanih z »setTimeout« in »setInterval«.
  • Povratne klice za asinhrone operacije, kot sta modula »fs« in »http«, obravnava »I/O Queue«.
  • »Check Queue« vsebuje povratne klice za funkcijo »setImmediate«, ki je edinstvena za Node.
  • »Zapri čakalno vrsto« upravlja povratne klice, povezane z dogodkom zapiranja katerega koli asinhronega opravila.
  • Nazadnje, v čakalni vrsti »Micro Task« sta dve različni čakalni vrsti:
    • Čakalna vrsta »nextTick« vsebuje povratne klice, povezane s funkcijo »process.nextTick«.
    • Čakalna vrsta »Promise« nadzoruje povratne klice, povezane z izvirnim Promise.

Funkcionalnost Event Loop v Node.js

Dogodkovna zanka deluje pod posebnimi zahtevami, ki nadzorujejo vrstni red izvajanja povratnega klica. Uporabnikova sinhrona koda Javascript ima prednost na začetku procesa, tako da se zanka dogodkov začne šele, ko je sklad klicev počiščen. Naslednje zaporedje izvajanja sledi strukturiranemu vzorcu:

Najvišjo prednost imajo povratni klici v čakalni vrsti mikroopravil, nato pa se premaknejo k izvajanju nalog v čakalni vrsti nextTick, ki jim sledijo naloge v čakalni vrsti Promise. Nato se obravnavajo procesi v povratnih klicih čakalne vrste časovnika, nato pa se čakalna vrsta mikroopravil ponovno obišče po vsakem povratnem klicu časovnika. Povratni klici v čakalnih vrstah V/I, preverjanje in zapiranje se nato izvedejo po podobnem vzorcu s čakalno vrsto mikroopravil, ki se obišče po vsaki fazi.

Zanka se nadaljuje z izvajanjem, če je treba obdelati več povratnih klicev. Ko se kodni skript konča ali ni več povratnih klicev za obdelavo, se zanka dogodkov učinkovito konča.

Zdaj, ko dobro razumemo zanko dogodkov, si poglejmo njene značilnosti.

Funkcije zanke dogodkov v Node.js

Glavne lastnosti so:

  • Dogodkovna zanka je neskončna zanka in nadaljuje z izvajanjem nalog takoj, ko jih prejme, in gre v način mirovanja, če ni nalog, vendar začne delovati takoj, ko je naloga prejeta.
  • Opravila v čakalni vrsti dogodkov se izvajajo le, ko je sklad prazen, kar pomeni, da ni aktivne operacije.
  • Povratne klice in obljube je mogoče uporabiti v zanki dogodkov.
  • Ker zanka dogodkov sledi načelu čakalne vrste vrste abstraktnih podatkov, izpolni prvo nalogo in nato nadaljuje z naslednjo.

Po temeljitem razumevanju zanke dogodkov in logike asinhronih in sinhronih izvedb lahko razumevanje različnih faz utrdi koncepte zanke dogodkov.

Node.js Faze zanke dogodkov

Kot je navedeno zgoraj, je zanka dogodkov pol neskončna. Ima veliko faz, vendar se nekatere faze uporabljajo za notranje ravnanje. Te faze nimajo nobenega vpliva na skript kode.

Dogodkovna zanka sledi funkcionalnosti čakalne vrste in izvaja nalogo po principu prvi vstopi in prvi ven. Načrtovane časovnike bo upravljal operacijski sistem, dokler ne potečejo. Potečeni časovniki se nato dodajo v čakalno vrsto povratnih klicev za časovnike.

Dogodkovna zanka izvaja naloge v čakalni vrsti časovnika eno za drugo, dokler ni več opravil ali doseže največje dovoljeno število opravil. V spodnjih razdelkih so razložene osnovne faze dogodkovnih zank.

Faza časovnikov

V Node.js je API časovnika, ki lahko načrtuje funkcije, ki naj bi se izvajale v prihodnosti. Po preteku dodeljenega časa se bo povratni klic časovnika izvedel takoj, ko jih je mogoče načrtovati; vendar lahko pride do zakasnitve na koncu operacijskega sistema ali zaradi izvajanja drugih povratnih klicev.

API časovnikov ima tri glavne funkcije:

  • setTimeout
  • setImmediate
  • setInterval

Zgoraj omenjene funkcije so sinhrone. Obseg faze časovnika v zanki dogodkov je omejen na funkciji setTimeout in setInterval. Medtem ko funkcija preverjanja obravnava funkcijo setImmediate.

Oglejmo si preprost primer, da utrdimo teoretični del:

// aplikacija.js

funkcija delayedFunction ( ) {

konzola. dnevnik ( 'zakasnjena funkcija se izvede po časovni omejitvi' ) ;

}

konzola. dnevnik ( 'Začetek programa' ) ;

setTimeout ( delayedFunction, 2000 ) ;

konzola. dnevnik ( 'Konec programa' ) ;

V tej kodi:

  • Program se zažene tako, da se v terminal zapiše izjava »Začetek programa«.
  • Nato se pokliče funkcija delayedFunction s časovnikom 2 ms, kodni skript se ne ustavi in ​​nadaljuje z obravnavo zakasnitve v ozadju.
  • Stavek »Konec programa« se zabeleži za prvim stavkom.
  • Po zakasnitvi 2 ms se stavek v delayedFunction zabeleži v terminal.

Izhod

Izhod bo prikazan kot:

Vidimo lahko, da koda ni ustavljena za obdelavo delayedFunction; premakne se naprej in po zakasnitvi se obdela povratni klic funkcije.

Čakajoči povratni klici

Zanka dogodkov preveri, ali se dogodki dogajajo, kot so branje datotek, omrežne dejavnosti ali vhodno/izhodne naloge, v fazi anketiranja. Pomembno je vedeti, da se v Node.js v tej fazi anketiranja obravnavajo samo nekateri dogodki. Vendar se lahko v naslednji ponovitvi zanke dogodkov nekateri dogodki odložijo na čakajočo fazo. To je ključni koncept, ki ga morate upoštevati pri optimizaciji in odpravljanju kode Node.js, ki vključuje zapletene operacije, ki jih vodijo dogodki.

Pomembno je razumeti, da med fazo čakajočih povratnih klicev zanka dogodkov doda odložene dogodke v čakalno vrsto čakajočih povratnih klicev in jih izvede. Ta faza obravnava tudi nekatere napake vtičnic TCP, ki jih je ustvaril sistem, kot so dogodki napak ECONNREFUSED v določenih operacijskih sistemih.

Spodaj je omenjen primer za utrjevanje koncepta:

// aplikacija.js
konst fs = zahtevati ( 'fs' ) ;
funkcija readFileAsync ( filePath, povratni klic ) {
fs. readFile ( './PromiseText.txt' , 'utf8' , funkcija ( napaka, podatki ) {
če ( napaka ) {
konzola. napaka ( ` Napaka bralna datoteka : $ { napaka sporočilo } ` ) ;
} drugače {
konzola. dnevnik ( ` mapa vsebino : $ { podatke } ` ) ;
}
poklicati nazaj ( ) ;
} ) ;
}
konzola. dnevnik ( 'Začetek programa' ) ;
readFileAsync ( './PromiseText.txt' , funkcija ( ) {
konzola. dnevnik ( 'Izveden povratni klic branja datoteke' ) ;
} ) ;
konzola. dnevnik ( 'Konec programa' ) ;

V tej kodi:

  • Program se zažene tako, da se v terminal zapiše izjava 'Začetek programa'.
  • ReadFileAsync je definiran asinhrono za branje vsebine datoteke »PromiseText.txt«. To je parametrizirana funkcija, ki izvede funkcijo povratnega klica, potem ko je datoteka prebrana.
  • Funkcija readFileAsync je poklicana za začetek postopka branja datoteke.
  • V procesu branja datoteke se program ne ustavi; namesto tega nadaljuje z naslednjim stavkom in ga prijavi v terminal 'Konec programa'.
  • Asinhroni dogodek branja datoteke se v ozadju obdela z zanko dogodkov.
  • Ko je datoteka prebrana asinhrono in je bila vsebina zabeležena v terminal, program zabeleži vsebino datoteke v terminal. Po tem zabeleži naslednje sporočilo »Povratni klic branja datoteke izveden«.
  • Dogodkovna zanka obravnava čakajoče operacije povratnega klica v naslednji fazi.

Izhod

Rezultat zgornje izvedbe je:

Nedejaven, faza priprave v Node.js

Faza mirovanja se uporablja za obravnavo notranjih funkcij v Node.js, zato ni standardna faza. Ne vpliva na skript kode. Faza mirovanja je kot obdobje premora za zanko dogodkov, med katero se v ozadju upravljajo opravila z nizko prioriteto. Preprost primer za razumevanje te faze je:

konst { nedejaven } = zahtevati ( 'idle-gc' ) ;

nedejaven. ignoriraj ( ) ;

V tej kodi je uporabljen modul 'idle-gc', ki omogoča ignoriranje faze mirovanja. To služi za obravnavo situacij, ko je zanka dogodkov zasedena in se naloge v ozadju ne izvajajo. Uporaba idle.ignore ne velja za optimalno, saj lahko povzroči težave z delovanjem.

Faza anketiranja v Node.js

Faza ankete v Node.js služi kot:

  • Obravnava dogodke v čakalni vrsti ankete in izvaja njihove ustrezne naloge.
  • Odloči se, koliko časa bo porabil za čakanje in preverjanje V/I operacij v procesu.

Ko zanka dogodkov vstopi v fazo ankete zaradi odsotnosti časovnika, bo izvedena ena od spodnjih nalog:

  • V fazi ankete zanke dogodkov v Node.js so čakajoči V/I dogodki postavljeni v čakalno vrsto in nato izvedeni v zaporednem postopku po načelu Prvi vstop in Prvi ven, dokler čakalna vrsta ne postane prazna. Med izvajanjem povratnih klicev so v akciji tudi čakalne vrste nextTick in mikroopravil. To zagotavlja gladkost in omogoča bolj učinkovito in zanesljivo upravljanje V/I operacij.
  • Če je čakalna vrsta prazna in skript ni bil načrtovan s funkcijo setImmediate(), se bo zanka dogodkov končala in nadaljevala v naslednjo fazo (preverjanje). Po drugi strani pa, če je razporejanje skripta opravila funkcija setImmediate(), zanka dogodkov omogoča, da se povratni klici dodajo v čakalno vrsto, ki jo bo izvedla.

To je najbolje ponazorjeno s preprostim primerom kode:

setTimeout ( ( ) => {

konzola. dnevnik ( 'Asinhrona operacija končana' ) ;

} , 2000 ) ;

konzola. dnevnik ( 'Začni' ) ;

setImmediate ( ( ) => {

konzola. dnevnik ( 'setImmediate povratni klic izveden' ) ;

} ) ;

konzola. dnevnik ( 'Konec' ) ;

V tej kodi:

  • Dve sporočili »Start« in »End« označujeta začetek in konec programa.
  • Funkcija setTimeout() nastavi funkcijo povratnega klica z zakasnitvijo 2 ms in v terminal zabeleži »Async operation completed«.
  • Funkcija setImmediate() zabeleži sporočilo »setImmediate back call executed« na terminal, potem ko je bilo sporočilo Start zabeleženo na terminalu.

Izhod

Izhod bi prikazal sporočila s samo minutnim opazovanjem, da »Asinhrona operacija končana« traja nekaj časa in se natisne za sporočilom »Konec«:

Faza preverjanja Node.js

Po izvedbi faze ankete se izvedejo povratni klici v fazi preverjanja. Če je kodni skript načrtovan s funkcijo setImmediate() in je funkcija ankete prosta, zanka dogodkov deluje tako, da se premakne neposredno v fazo preverjanja, namesto da ostane nedejavna. Funkcija setImmediate() je edinstven časovnik, ki deluje v različnih fazah zanke dogodkov.

API libuv se uporablja za načrtovanje izvedb povratnega klica po zaključku izvedbe faze ankete. Med izvajanjem kode preide zanka dogodkov v fazo ankete, v kateri čaka na dohodne zahteve za povezavo. V drugem primeru, če je povratni klic načrtovan s funkcijo setImmediate() in se faza ankete konča brez kakršne koli dejavnosti, se bo premaknila v fazo preverjanja namesto čakanja. Za razumevanje si oglejte spodnji primer:

// aplikacija.js

konzola. dnevnik ( 'Začni' ) ;

setImmediate ( ( ) => {

konzola. dnevnik ( 'Takojšen povratni klic' ) ;

} ) ;

konzola. dnevnik ( 'Konec' ) ;

V tej kodi so na terminalu prijavljena tri sporočila. Funkcija setImmediate() nato končno pošlje povratni klic, da zabeleži sporočilo ' Takojšen povratni klic ” do terminala.

Izhod

Izhod zgornje kode se bo prikazal v naslednjem zaporedju:

Node.js zapre povratne klice

Node.js uporablja to fazo zapiranja za izvajanje povratnih klicev za zapiranje dogodkov in končanje ponovitve zanke dogodkov. Ko je povezava zaprta, zanka dogodkov obravnava zaključne dogodke v tej fazi. V tej fazi zanke dogodkov se »nextTick()« in mikroopravila ustvarijo in obdelajo podobno kot druge faze.

Funkcija process.exit se uporablja za končanje zanke dogodkov v katerem koli trenutku. Zanka dogodkov ne bo upoštevala morebitnih čakajočih asinhronih operacij in proces Node.js se bo zaključil.

Preprost primer, ki ga je treba upoštevati, je:

// aplikacija.js
konst mreža = zahtevati ( 'mreža' ) ;
konst strežnik = mreža. createServer ( ( vtičnica ) => {
vtičnica. na ( 'blizu' , ( ) => {
konzola. dnevnik ( 'Vtičnica zaprta' ) ;
} ) ;
vtičnica. na ( 'podatki' , ( podatke ) => {
konzola. dnevnik ( 'Prejeti podatki:' , podatki. toString ( ) ) ;
} ) ;
} ) ;
strežnik. na ( 'blizu' , ( ) => {
konzola. dnevnik ( 'Strežnik zaprt' ) ;
} ) ;
konst pristanišče = 3000 ;
strežnik. poslušaj ( pristanišče, ( ) => {
konzola. dnevnik ( `Strežnik posluša na vratih $ { pristanišče } ` ) ;
} ) ;
setTimeout ( ( ) => {
konzola. dnevnik ( 'Zapiranje strežnika po 10 sekundah' ) ;
strežnik. blizu ( ) ;
postopek. izhod ( ) ;
} , 10000 ) ;

V tej kodi:

  • const net = require('net') ' uvozi mrežni modul, potreben za upravljanje strežnika TCP in ' const server = net.createServer((socket) => { ” ustvari nov primerek strežnika TCP.
  • socket.on('close', () => {… } ” posluša “close” na vseh vtičnicah. Ko je povezava z vtičnico zaprta, se na terminalu zabeleži sporočilo »Vtičnica je zaprta«.
  • socket.on('podatki', (podatki) => {} ” preveri vhodne podatke iz vseh posameznih vtičnic in jih natisne s funkcijo “.toString()”.
  • server.on('close', () => {…} « preveri dogodek »close« na samem strežniku in ko je povezava s strežnikom zaprta, v terminal zabeleži sporočilo »Server Closed«.
  • server.listen(vrata, () => {…} ” posluša dohodne povezave na vratih.
  • setTimeout(() => {…} ” nastavi časovnik 10 ms za zaprtje strežnika.

S tem se zaključi razprava o različnih fazah zanke dogodkov v Node.js. Preden prehitro zaključimo, se pogovorimo še o eni zadnji stvari, in sicer o tem, kako izstopiti iz zanke dogodkov v Node.js.

Izhod iz zanke dogodkov v Node.js

Dogodkovna zanka je v fazi izvajanja, dokler je nekaj nalog v vseh čakalnih vrstah faz dogajalne zanke. Dogodkovna zanka se konča po oddaji izhodne faze in povratni klic izhodnega poslušalca se vrne, če v čakalnih vrstah ni več opravil.

Izrecni način za končanje zanke dogodkov je uporaba metode ».exit«. Aktivni procesi Node.js se bodo takoj končali, takoj ko je poklicana funkcija process.exit. Vsi načrtovani in čakajoči dogodki bodo izpuščeni:

postopek. na ( 'izhod' , ( Koda ) => {

konzola. dnevnik ( `Izhod z izhodno kodo : $ { Koda } ` ) ;

} ) ;

postopek. izhod ( 1 ) ;

Uporabniki lahko poslušajo funkcijo .exit. Upoštevati je treba, da mora biti funkcija ».exit« sinhrona, saj bo program Node.js zaprl takoj, ko bo poslušal ta dogodek.

S tem se zaključi razprava o zanki dogodkov. Poglobljen članek, ki zajema vse koncepte, faze in primere, povezane z zanko dogodkov.

Zaključek

Preden razumete dogajalno zanko, lahko pregled sinhronih in asinhronih konceptov pomaga razumeti potek kode v dogodkižni zanki. Sinhrono izvajanje pomeni izvajanje po korakih, medtem ko asinhrono izvajanje pomeni zaustavitev nekaterih korakov, ne da bi čakali na njihov zaključek. V članku je obravnavano delovanje zanke dogodkov skupaj z vsemi fazami skupaj z ustreznimi primeri.