À propos de ce cours
Chapitre 11 — Les objets prédéfinis et l'ordonnancement · L'ordonnancement avec setTimeout et setInterval
• exécuter une fonction après un délai avec
setTimeout; • répéter une fonction à intervalle régulier avec
setInterval; • annuler une minuterie avec
clearTimeout et clearInterval; • comprendre pourquoi le délai n'est qu'un minimum.
1. Deux minuteries

Figure 1 — setTimeout exécute une fois, setInterval répète jusqu'à clearInterval.
const id1 = setTimeout(fonction, delaiEnMs, arg1, arg2); // une fois, après le délai
const id2 = setInterval(fonction, delaiEnMs); // en boucle, toutes les delaiEnMs
clearTimeout(id1); // annule avant l'exécution
clearInterval(id2); // arrête la répétition
Les deux méthodes appartiennent à window (elles existent aussi dans Node.js). Elles renvoient un identifiant, qu'il faut
conserver dans une variable pour pouvoir annuler. On passe la fonction sans l'appeler: setTimeout(afficher, 1000), pas
setTimeout(afficher(), 1000).
2. L'ordre d'exécution
const debut = Date.now();
const t = () => `${Math.round((Date.now() - debut) / 100) / 10} s`;
console.log("1. Début du script");
// setTimeout : exécuter une fonction une seule fois, après un délai
setTimeout(() => console.log(`4. setTimeout de 1000 ms → exécuté vers ${t()}`), 1000);
// Même avec un délai de 0, la fonction attend la fin du script en cours
setTimeout(() => console.log("3. setTimeout de 0 ms → après le code synchrone"), 0);
// clearTimeout : annuler avant l'exécution
const annule = setTimeout(() => console.log("jamais affiché"), 500);
clearTimeout(annule);
// setInterval : répéter jusqu'à clearInterval
let compte = 3;
const minuteur = setInterval(() => {
console.log(` compte à rebours : ${compte} (${t()})`);
compte--;
if (compte === 0) {
clearInterval(minuteur);
console.log(`5. Fin du compte à rebours vers ${t()}`);
}
}, 400);
// Passer des arguments à la fonction
setTimeout((nom, module) => console.log(` Bonjour ${nom}, module ${module}`), 200, "Amina", "M107");
console.log("2. Fin du script (les minuteries n'ont pas encore été exécutées)");
Résultat dans la console (Node.js)
1. Début du script 2. Fin du script (les minuteries n'ont pas encore été exécutées) 3. setTimeout de 0 ms → après le code synchrone Bonjour Amina, module M107 compte à rebours : 3 (0.4 s) compte à rebours : 2 (0.8 s) 4. setTimeout de 1000 ms → exécuté vers 1 s compte à rebours : 1 (1.2 s) 5. Fin du compte à rebours vers 1.2 s
Les messages 1 et 2 s'affichent d'abord : les minuteries ne s'exécutent qu'après la fin du code en cours, même avec un délai de 0. Le délai est donc un minimum, pas une garantie : si le navigateur est occupé, la fonction attend son tour (vous comprendrez pourquoi avec la boucle d'événements, leçon 18.2). Dans un onglet en arrière-plan, les navigateurs ralentissent aussi les minuteries.
3. Dans une page : horloge et compte à rebours
📄 l7_minuteur.html
<!DOCTYPE html>
<html lang="fr">
<head><meta charset="UTF-8"><link rel="stylesheet" href="style.css">
<style>
#horloge { font: 700 42px ui-monospace, monospace; color: #1565c0; }
#reste { font: 700 32px ui-monospace, monospace; }
.fini { color: #c62828; }
</style></head>
<body>
<div class="carte">Il est <span id="horloge">--:--:--</span></div>
<div class="carte">
Compte à rebours : <span id="reste">00:10</span>
<p><button id="demarrer">Démarrer</button> <button id="pause">Pause</button> <button id="raz">Remettre à zéro</button></p>
</div>
<div class="carte" id="notif">Une notification apparaîtra dans 2 secondes…</div>
<script>
// 1. Horloge : setInterval, mise à jour chaque seconde
const horloge = document.querySelector("#horloge");
const format = new Intl.DateTimeFormat("fr-FR", { timeStyle: "medium" });
function afficherHeure() { horloge.textContent = format.format(new Date()); }
afficherHeure(); // tout de suite, sans attendre 1 s
setInterval(afficherHeure, 1000);
// 2. Compte à rebours avec pause : on garde l'identifiant pour clearInterval
const DUREE = 10;
let reste = DUREE;
let minuteur = null;
const affichage = document.querySelector("#reste");
const deuxChiffres = (n) => String(n).padStart(2, "0");
function afficherReste() {
affichage.textContent = `${deuxChiffres(Math.floor(reste / 60))}:${deuxChiffres(reste % 60)}`;
affichage.classList.toggle("fini", reste === 0);
}
function tic() {
reste--;
afficherReste();
if (reste === 0) { clearInterval(minuteur); minuteur = null; }
}
document.querySelector("#demarrer").addEventListener("click", () => {
if (minuteur !== null || reste === 0) return; // éviter deux minuteries en même temps
minuteur = setInterval(tic, 1000);
});
document.querySelector("#pause").addEventListener("click", () => {
clearInterval(minuteur);
minuteur = null;
});
document.querySelector("#raz").addEventListener("click", () => {
clearInterval(minuteur);
minuteur = null;
reste = DUREE;
afficherReste();
});
// 3. Une action différée : setTimeout
setTimeout(() => {
const notif = document.querySelector("#notif");
notif.textContent = "Pensez à rendre votre TP avant vendredi !";
notif.classList.add("actif");
}, 2000);
</script>
</body>
</html>

Après 3 s de compte à rebours, 2 s de pause, puis la fin du décompte
- L'horloge est affichée une première fois tout de suite, puis toutes les secondes : sinon elle resterait vide pendant la première seconde.
- Le bouton Démarrer vérifie qu'aucune minuterie ne tourne déjà : sans ce test, deux clics lanceraient deux
setIntervalet le décompte irait deux fois plus vite. - La pause appelle
clearIntervalet remet l'identifiant ànull.
Pour un chronomètre précis, ne comptez pas les « tics » :
setInterval(f, 1000) dérive de quelques millisecondes à chaque fois.
Mémorisez l'heure de départ (Date.now()) et calculez le temps écoulé à chaque affichage. Pour une animation fluide, utilisez
requestAnimationFrame (chapitre 15). Évitez aussi setTimeout("code", 1000) avec une chaîne : c'est l'équivalent de eval. •
setTimeout(f, ms): une fois ; setInterval(f, ms): en boucle.• Gardez l'identifiant renvoyé pour
clearTimeout / clearInterval. • Le délai est un minimum : la fonction s'exécute après le code en cours.
• Un chronomètre précis calcule le temps écoulé à partir de l'heure de départ.
🛠 Activité 7 — Le minuteur de cuisine
Mission : Réalisez un minuteur : on choisit une durée en minutes et secondes, on démarre, on peut mettre en pause, et une alerte visuelle signale la fin.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Affichez le temps restant au format
MM:SS. Quelles opérations deMathet quelle méthode de chaîne utilisez-vous ? - Démarrez le décompte avec
setInterval. Cliquez trois fois sur Démarrer : que se passe-t-il ? Comment l'empêchez-vous ? - Programmez la pause et la reprise. Que devez-vous mémoriser pour reprendre là où vous en étiez ?
- Passez l'onglet en arrière-plan pendant une minute, puis revenez. Le minuteur est-il en retard ? Corrigez-le en calculant le temps restant à partir de l'heure de fin prévue (
Date.now()). - À la fin, faites clignoter le titre de l'onglet (« ⏰ Terminé ! » / titre normal) toutes les 500 ms, et arrêtez le clignotement quand l'utilisateur revient sur la page. Combien de minuteries gérez-vous en même temps ?
- Ajoutez un message « Plus que 10 secondes ! » qui s'affiche une seule fois. Utilisez-vous
setTimeoutou un test dans votresetInterval? Justifiez.
Je vérifie / je rends :
- ☐ Le minuteur complet et la réponse argumentée à la question 4.
← Ouvrir des fenêtres : window.open, close et openerTP 11 : Créer un jeu en JavaScript (Devine le nombre) →
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !