Asynchrone

1 setTimeout & setInterval

// Exécuter UNE FOIS après un délai (ms)
setTimeout(() => {
  console.log("1 seconde plus tard !");
}, 1000);

// Répéter à interval régulier
const timer = setInterval(() => {
  console.log("Toutes les 2 secondes");
}, 2000);

// Arrêter le timer
clearInterval(timer);

setTimeout(maFonction(), 1000); // appelle maFonction IMMÉDIATEMENT
setTimeout(maFonction,   1000); // ✅ passe la référence de la fonction

2 Promises

Une Promise représente une valeur qui n'est pas encore disponible.

États : pending → resolved (fulfilled) ou rejected

// Créer une Promise
const maPromise = new Promise((resolve, reject) => {
  const succes = Math.random() > 0.5;
  if (succes) {
    resolve("Ça a marché !");
  } else {
    reject("Erreur !");
  }
});

// Consommer une Promise
maPromise
  .then(valeur => console.log("Succès :", valeur))
  .catch(erreur => console.log("Échec :", erreur))
  .finally(() => console.log("Toujours exécuté"));

3 async / await — la syntaxe moderne

async/await est du "sucre syntaxique" par-dessus les Promises. Plus lisible, plus proche du code synchrone.

// Une fonction async retourne toujours une Promise
async function chargerDonnees() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json(); // .json() est aussi async
    return data;
  } catch (erreur) {
    console.error("Erreur :", erreur);
  }
}

// Appeler une fonction async
chargerDonnees().then(data => console.log(data));
// ou dans un contexte async :
const data = await chargerDonnees();

// await en dehors d'une fonction async → SyntaxError
const data = await fetch(url); // ❌ au niveau module sans "type=module"

async function ok() {
  const data = await fetch(url); // ✅
}

4 fetch() — appeler une API

async function getUsers() {
  const response = await fetch('https://jsonplaceholder.typicode.com/users');

  // Toujours vérifier le statut HTTP
  if (!response.ok) {
    throw new Error(`Erreur HTTP : ${response.status}`);
  }

  const users = await response.json();
  return users;
}

Avec des paramètres (POST, headers) :

const response = await fetch('/api/users', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ nom: "Alice" }),
});

5 Promises en parallèle

// Attendre TOUTES les promises (en parallèle, plus rapide)
const [users, posts] = await Promise.all([
  fetch('https://jsonplaceholder.typicode.com/users').then(r => r.json()),
  fetch('https://jsonplaceholder.typicode.com/posts').then(r => r.json()),
]);
// users ET posts sont disponibles en même temps

6 try / catch / finally

async function exemple() {
  try {
    const data = await fetch('/api/donnees').then(r => r.json());
    afficher(data);
  } catch (err) {
    // Réseau coupé, JSON invalide, erreur serveur...
    console.error("Quelque chose a raté :", err.message);
    afficherErreur();
  } finally {
    // Toujours exécuté — pour cacher un spinner par ex.
    cacherChargement();
  }
}

Résumé rapide