De uitvoering onderbreken in een Node.js-programma

In tegenstelling tot andere programmeertalen heeft JavaScript geen ingebouwde slaapmethode. Je kunt dus niet zomaar een sleep()-functie aanroepen om een ​​Node.js-programma te pauzeren. Er zijn echter andere manieren waarop u een programma een bepaalde tijd kunt laten wachten.

In deze zelfstudie worden drie benaderingen besproken: setTimeout, async/wait en het sleep-promise-pakket.

SetTimeout() gebruiken om op een specifieke tijd te wachten

De setTimeout() functie plant code voor de runtime om uit te voeren zodra een ingestelde hoeveelheid tijd is verstreken. Het accepteert een functie en een vertragingstijd in milliseconden. Hier is de syntaxis:

setTime-out(functie(), timeInMs)

Stel bijvoorbeeld dat u een functie had die op de console wordt afgedrukt:

functieprintSentence() {
 console.log("setTimeout() gebruiken")
}

Om de bovenstaande functie uit te voeren nadat twee seconden zijn verstreken, geeft u de functie en de vertragingstijd van 2000 ms door aan de setTimeout() functie:

setTimeout (printSentence, 2000)

Hoewel dit werkt, is het niet gegarandeerd dat uw functie precies na twee seconden wordt uitgevoerd. Het zal zeker minstens die hoeveelheid tijd kosten, maar het kan meer duren.

Is setTimeout() nauwkeurig?

Ja, maar met enkele kanttekeningen. setTimeout() is een asynchrone JavaScript-functie wat betekent dat het niet blokkeert. De code die u plant, wordt toegevoegd aan de gebeurtenislus terwijl de rest van uw programma doorgaat.

Nadat de vertragingstijd is verstreken, voert uw programma de geplande code uit, maar alleen als het vrij is om dit te doen. Als er andere code in de call-stack zit, wordt deze als eerste uitgevoerd, zelfs als de geplande code moet worden uitgevoerd. Dit is waar extra vertragingstijd kan optreden, vandaar de onnauwkeurigheid.

Denk aan het volgende programma.

console.log("Hallo Wereld!")
functieprintSentence() {
 console.log("setTimeout() gebruiken")
}
setTimeout (printSentence, 2000)
console.log("Klaar")

Dit is wat de console zal weergeven wanneer u deze uitvoert:

Hallo Wereld!
Klaar
setTimeout() gebruiken

Dit programma introduceert een vertraging, maar het vertraagt ​​alleen de code waaraan het wordt doorgegeven setTimeout(). De rest van het programma gaat verder, waarbij de geplande code het pas onderbreekt als de duur is verstreken. Als je al deze code in volgorde wilt uitvoeren, met een pauze in het midden, gebruik dan setTimeout() zal niet werken.

Een alternatief is om synchrone code te schrijven die de uitvoering blokkeert zolang als nodig is. U kunt bijvoorbeeld een doen terwijl lus om de uitvoeringsthread te blokkeren totdat de vertragingstijd om is:

functievertraging(Mevrouw) {
const datum = Datum.nu();
laat huidigeDatum = nul;
doen {
 huidigeDatum = Datum.nu();
 } terwijl (currentDate - datum < ms);
}
console.log("Hallo Wereld");
vertraging (2000);
console.log("Wordt na 2 seconden afgedrukt!");

De vertraging() functie loopt door totdat de huidige tijd gelijk is aan of groter is dan de starttijd plus de vertraging. Het nadeel van deze aanpak is dat het CPU-intensief is, vooral met grote vertragingen. De doen...terwijl lus moet de resterende tijd na elke milliseconde berekenen.

Async/Await gebruiken om een ​​Node.js-programma uit te stellen

Een wachten expression zorgt ervoor dat de uitvoering wordt gepauzeerd totdat een belofte is opgelost. Hiermee kunt u asynchrone code uitvoeren alsof deze synchroon is, maar efficiënter dan door de uitvoering handmatig te blokkeren. U kunt wachten alleen gebruiken in een functie die is gemarkeerd met asynchrone.

functievertraging(tijd) {
opbrengstnieuweBelofte(oplossen => setTimeout (oplossen, tijd));
}
asynchronefunctieprintSentence() {
 console.log("Hallo Wereld")
wachten vertraging(2000);
 console.log("Wordt na 2 seconden afgedrukt");
}
printSentence();

Dit is de output van het bovenstaande programma:

Hallo Wereld
Wordt na 2 seconden afgedrukt

Het slaapbelofte-pakket gebruiken

De slaapbelofte pakket vereenvoudigt het pauzeren van Node.js-programma's. U hoeft het alleen maar aan te roepen en de vertragingstijd in milliseconden op te geven.

Begin met het installeren via npm:

npm installerenslaap-belofte

Hier is een voorbeeld van hoe u het in uw programma zou kunnen gebruiken:

const slapen = vereisen('slaapbelofte');
(asynchrone () => {
 console.log("Hallo Wereld.");
wachten slaap(2000);
 console.log("Wordt na twee seconden afgedrukt.");
})();

Wanneer u het programma uitvoert, is de uitvoer als volgt.

Hallo Wereld.
Wordt na twee seconden afgedrukt.

Een geschikte aanpak kiezen

Het implementeren van een slaapfunctie in Node.js kan lastig zijn. Als je besluit hoe je het gaat aanpakken, bedenk dan wat je wilt bereiken. Als je gewoon een code wilt uitstellen, voor een minimale hoeveelheid tijd, setTimeout() is een goede optie. Maar als je de uitvoering van je hele programma wilt pauzeren, gebruik dan asynchroon/wachten.

Synchroon vs. Asynchrone programmering: hoe zijn ze anders?

Lees volgende

Over de auteur