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

Le hoisting (remontée des déclarations)

Le hoisting (remontée des déclarations). Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre ce que le moteur prépare avant d'exécuter le code ; prévoir le comportement de var, let, c...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Le hoisting (remontée des déclarations). Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre ce que le moteur prépare avant d'exécuter le code ; prévoir le comportement de var, let, const utilisés avant leur déclaration ; distinguer une déclaration de fonction d'une fonction rangée dans une variable ; adopter les habitudes qui évitent les surprises.

Chapitre 3 — Les variables, les types et les opérateurs · Le hoisting (remontée des déclarations)

🎯 Objectifs de la leçon
• comprendre ce que le moteur prépare avant d'exécuter le code ;
• prévoir le comportement de var, let, const utilisés avant leur déclaration ;
• distinguer une déclaration de fonction d'une fonction rangée dans une variable ;
• adopter les habitudes qui évitent les surprises.

1. Deux passages sur le code

Avant d'exécuter un script ou une fonction, le moteur JavaScript le parcourt une première fois pour enregistrer toutes les déclarations de la portée. Tout se passe comme si les déclarations « remontaient » en haut de leur portée : c'est le hoisting (remontée). Seules les déclarations remontent, jamais les affectations.

Hoisting
Figure 1 — Le code tel qu'on l'écrit, et ce que le moteur prépare avant l'exécution.

// 1. var : la déclaration remonte, pas l'affectation
console.log("ville avant :", ville);
var ville = "Fès";
console.log("ville après :", ville);

// 2. let et const : la déclaration remonte, mais la variable est inaccessible
//    jusqu'à sa ligne (zone morte temporaire)
try {
  console.log(pays);
} catch (e) {
  console.log("pays avant sa déclaration →", e.name + " : " + e.message);
}
let pays = "Maroc";

// 3. Une déclaration de fonction remonte entièrement : on peut l'appeler avant
console.log(saluer("Amina"));
function saluer(nom) {
  return "Bonjour " + nom;
}

// 4. Une fonction rangée dans une variable suit les règles de la variable
try {
  console.log(direAuRevoir("Karim"));
} catch (e) {
  console.log("direAuRevoir avant sa ligne →", e.name);
}
const direAuRevoir = (nom) => "Au revoir " + nom;
console.log(direAuRevoir("Karim"));

// 5. Ce que le moteur « voit » pour l'exemple 1
//    var ville;            ← déclaration remontée, valeur undefined
//    console.log(ville);
//    ville = "Fès";        ← l'affectation reste à sa place

Résultat dans la console

ville avant : undefined
ville après : Fès
pays avant sa déclaration → ReferenceError : Cannot access 'pays' before initialization
Bonjour Amina
direAuRevoir avant sa ligne → ReferenceError
Au revoir Karim

2. Ce qu'il faut retenir pour chaque déclaration

  • var: la variable existe dès le début de la portée et vaut undefined jusqu'à la ligne d'affectation. Aucune erreur, mais une valeur inattendue : c'est le pire cas, car le bug passe inaperçu.
  • let et const: elles sont enregistrées aussi, mais restent inaccessibles jusqu'à leur ligne : c'est la zone morte temporaire (temporal dead zone). Toute lecture provoque ReferenceError : Cannot access … before initialization. L'erreur est franche : tant mieux.
  • Déclaration de fonction (function saluer() { … }) : elle remonte entièrement, on peut l'appeler avant sa ligne. C'est pratique pour placer les fonctions utilitaires en bas du fichier.
  • Fonction rangée dans une variable (const f = () => …) : elle suit la règle de const (chapitre 10).
⚠️ Attention
Le hoisting n'est pas une technique à utiliser mais un comportement à connaître pour comprendre certains bugs. Déclarez vos variables avant de les utiliser, en haut de leur portée, avec const ou let.
✅ Correction par rapport à l'ancienne version
Nouvelle leçon : le hoisting n'était pas traité. Exemples exécutés pour var, let, les déclarations de fonctions et les fonctions fléchées, schéma de ce que prépare le moteur, notion de zone morte temporaire ; deux activités de prédiction.
ℹ️ À retenir
• Les déclarations remontent en haut de leur portée, pas les affectations.
• var utilisée trop tôt vaut undefined; let/const provoquent une ReferenceError.
• Une déclaration function est utilisable avant sa ligne ; une fonction dans une const non.
• Déclarer avant d'utiliser évite tous ces cas.

🛠 Activité 7 — Prédire l'affichage

Mission : Pour chaque programme, écrivez votre prédiction avant de l'exécuter.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. console.log(a); var a = 5; console.log(a); — qu'affiche chaque ligne ? Réécrivez le programme comme le moteur le « voit ».
  2. console.log(b); let b = 5; — que se passe-t-il ? Quel est le nom exact de l'erreur et que signifie son message ?
  3. console.log(total(2, 3)); function total(x, y) { return x + y; } — ce programme fonctionne-t-il ? Pourquoi ?
  4. Même question avec const total = (x, y) => x + y; placé après l'appel.
  5. Parmi vos prédictions, lesquelles étaient fausses ? Qu'avez-vous appris ?

Je vérifie / je rends :

  • ☐ Un tableau : programme, prédiction, résultat réel, explication.

🛠 Activité 8 — Corriger un bug de hoisting

Mission : Le programme suivant affiche « Bienvenue undefined » au lieu du nom : afficher(); var nom = "Karim"; function afficher() { console.log("Bienvenue " + nom); }.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Expliquez pourquoi afficher() peut être appelée mais affiche undefined.
  2. Remplacez var par let. Quel est maintenant le résultat ? Est-ce mieux ou pire ? Pourquoi ?
  3. Corrigez le programme pour qu'il affiche « Bienvenue Karim », sans supprimer la fonction.
  4. Énoncez en une phrase la règle d'organisation qui évite ce genre de bug.

Je vérifie / je rends :

  • ☐ Le programme corrigé et l'explication de la question 2.

← var, let et const : portée des variables et mode strictLes types de données (String, Number, Boolean, BigInt, Symbol, null, undefined, Object) →

Cet article vous a-t-il aidé ?