Module Timers de Node.js
Modules intégrés de Node.jsde Node.jstimersLe module fournit une série de fonctions permettant d'exécuter du code après un délai spécifié ou à intervalles réguliers de manière répétée. Ces fonctionnalités sont très utiles pour mettre en œuvre une exécution différée, des tâches périodiques et un contrôle des délais d'attente.
Bien quetimersle module est un module de base de Node.js, mais ses méthodes telles quesetTimeout(), setInterval()etsetImmediate()sont disponibles globalement sans importation explicite.
Fonctions de minuterie principales
setTimeout()
setTimeout()La fonction est utilisée pour exécuter une fonction de rappel une fois après un nombre spécifié de millisecondes.
Exemple
setTimeout(() => {
console.log('Ce message sera affiché après 2 secondes');
}, 2000);
Description du paramètre
- Fonction de rappel: La fonction à exécuter
- Temps de délai: Temps en millisecondes (1000 ms = 1 seconde)
- Paramètres facultatifs: Paramètres supplémentaires transmis à la fonction de rappel
Exemple
setTimeout((name, age) => {
console.log(`Bonjour, ${name}, vous avez ${age}ans`);
}, 1000, 'Zhang San', 25);
clearTimeout()
clearTimeout()Utilisé pour annuler unsetTimeout()minuteur précédemment défini.
Exemple
console.log('Ce message ne sera pas affiché');
}, 2000);
clearTimeout(timerId); // Annuler le minuteur
setInterval()
setInterval()La fonction est utilisée pour exécuter de manière répétée une fonction de rappel à des intervalles spécifiés en millisecondes.
Exemple
let counter = 0;
const intervalId = setInterval(() => {
counter++;
console.log(`Ceci est l'exécution ${counter}`);
if (counter === 5) {
clearInterval(intervalId); // Arrêter le minuteur
}
}, 1000);
clearInterval()
clearInterval()Utilisé pour arrêter unsetInterval()minuteur répétitif défini précédemment.
Exemple
console.log('Ce message sera affiché de manière répétée');
}, 1000);
// Arrêter le minuteur après 5 secondes
setTimeout(() => {
clearInterval(intervalId);
}, 5000);
setImmediate()
setImmediate()La fonction est utilisée pour exécuter une fonction de rappel à la fin de la boucle d'événements actuelle.
Exemple
setImmediate(() => {
console.log('Fonction de rappel exécutée immédiatement');
});
console.log('Fin');
// Ordre de sortie :
// Début
// Fin
// Callback exécuté immédiatement
clearImmediate()
clearImmediate()Utilisé pour annuler unsetImmediate()callback immédiat.
Exemple
console.log('Ce message ne sera pas affiché');
});
clearImmediate(immediateId);
Ordre d'exécution des minuteurs
Il est très important de comprendre la boucle d'événements de Node.js pour maîtriser l'ordre d'exécution des minuteurs. Voici l'ordre d'exécution de plusieurs minuteurs :
- Code synchrone: exécuté en premier
- process.nextTick(): exécuté immédiatement après la fin de la phase actuelle
- Fonctions de rappel de Promise: file d'attente des microtâches
- setImmediate(): exécuté après les fonctions de rappel d'E/S
- setTimeout() et setInterval(): exécutés dans la phase de vérification
Exemple
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('Promise'));
console.log('Fin');
// Ordre de sortie typique :
// Début
// Fin
// nextTick
// Promise
// setTimeout
// setImmediate
Utilisation avancée et notes
Annulation des minuteurs
Toutes les fonctions de minuteur renvoient unTimeoutobjet, qui peut être utilisé pour annuler le minuteur. Il n'y a pas de risque à appeler la fonction d'annulation même si le minuteur s'est déjà exécuté.
Exemple
clearTimeout(timeout); // Appel sans risque même si le minuteur s'est déjà exécuté
Précision des minuteurs
Les minuteurs Node.js ne garantissent pas un temps d'exécution précis ; ils représentent un temps d'attente minimum. La charge système et d'autres facteurs peuvent affecter le temps d'exécution réel.
Fuites de mémoire
Oublier d'annulersetInterval()Les timers sont une source courante de fuites de mémoire. Assurez-vous de les effacer lorsqu'ils ne sont plus nécessaires.
Exemple
setInterval(() => {
// Effectuer une opération
}, 1000);
// Approche correcte - effacer le timer au moment approprié
const interval = setInterval(() => {
// Effectuer une opération
if (someCondition) {
clearInterval(interval);
}
}, 1000);
setTimeout récursif au lieu de setInterval
Pour les tâches qui nécessitent un intervalle fixe mais dont le temps d'exécution est incertain à chaque fois, utiliser un setTimeout récursifsetTimeoutComparersetIntervalest plus fiable.
Exemple
console.log('Exécution de la tâche...');
// Simuler un temps d'exécution incertain pour une tâche
const delay = Math.random() * 1000;
setTimeout(doSomething, 1000 + delay);
}
setTimeout(doSomething, 1000);
Exemples d'applications pratiques
Implémentation d'un compte à rebours simple
Exemple
let current = seconds;
console.log(`Début du compte à rebours : ${current}seconds`);
const timer = setInterval(() => {
current--;
if (current <= 0) {
clearInterval(timer);
console.log('Compte à rebours terminé !');
} else {
console.log(`Temps restant : ${current}seconds`);
}
}, 1000);
}
countdown(5);
Gestion des délais d’attente des requêtes
Exemple
return new Promise((resolve, reject) => {
const timeoutId = setTimeout(() => {
reject(new Error(`Délai d’attente de la requête (${timeout}ms）`));
}, timeout);
fetch(url)
.then(response => {
clearTimeout(timeoutId);
resolve(response);
})
.catch(error => {
clearTimeout(timeoutId);
reject(error);
});
});
}
// Exemple d'utilisation
fetchWithTimeout('https://api.example.com/data')
.then(data => console.log(data))
.catch(error => console.error(error));
En maîtrisant letimersmodule de Node.js, vous pouvez contrôler efficacement le moment d’exécution du code et mettre en œuvre diverses tâches planifiées et flux de contrôle asynchrones.