Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

L'ordonnancement avec setTimeout et setInterval

L'ordonnancement avec setTimeout et setInterval. Dans cette leçon du cours JavaScript, vous apprendrez à : exécuter une fonction après un délai avec setTimeout ; répéter une fonction à intervalle régu...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

L'ordonnancement avec setTimeout et setInterval. Dans cette leçon du cours JavaScript, vous apprendrez à : 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.

Chapitre 11 — Les objets prédéfinis et l'ordonnancement · L'ordonnancement avec setTimeout et setInterval

🎯 Objectifs de la leçon
• 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

setTimeout et setInterval sur une ligne de temps
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
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 setInterval et le décompte irait deux fois plus vite.
  • La pause appelle clearInterval et remet l'identifiant à null.
⚠️ Attention
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.
ℹ️ À retenir
• 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) :

  1. Affichez le temps restant au format MM:SS. Quelles opérations de Math et quelle méthode de chaîne utilisez-vous ?
  2. Démarrez le décompte avec setInterval. Cliquez trois fois sur Démarrer : que se passe-t-il ? Comment l'empêchez-vous ?
  3. Programmez la pause et la reprise. Que devez-vous mémoriser pour reprendre là où vous en étiez ?
  4. 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()).
  5. À 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 ?
  6. Ajoutez un message « Plus que 10 secondes ! » qui s'affiche une seule fois. Utilisez-vous setTimeout ou un test dans votre setInterval? 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é ?