Portée d’une Fonction et Pile de Fonctions en JavaScript

Dans cet exemple, fonctionGlobale peut être appelée de n’importe où dans le code, car elle a une portée globale.

Portée Locale des Fonctions

Les fonctions définies à l’intérieur d’autres fonctions ou blocs de code ont une portée locale. Elles ne peuvent être appelées qu’à l’intérieur de la fonction ou du bloc où elles ont été définies.

Exemple avec une Fonction Locale

Ici, interieure est définie à l’intérieur de exterieure, donc elle ne peut être appelée qu’à l’intérieur de exterieure.

Portée des Fonctions dans des Blocs de Code

Avec l’introduction de let et const en ES6, les fonctions peuvent également être définies dans des blocs de code tels que des boucles ou des conditions, limitant leur portée à ce bloc spécifique.

Exemple avec une Fonction dans un Bloc

Ajoute Livre 1
-----
Livre 1

Ajoute Livre 2
-----
Livre 2
Livre 1

Retire Livre 2
-----
Livre 1

Consulte le sommet : Livre 1

Application de la pile en Programmation

En programmation, la pile est couramment utilisée pour gérer les appels de fonctions. Chaque fois qu’une fonction est appelée, une nouvelle entrée est ajoutée (push) à la pile. Lorsque la fonction termine son exécution, elle est retirée (pop) de la pile. Cette gestion ordonnée permet de suivre le déroulement et le retour des fonctions.

Exemple en JavaScript

Reprenons l’exemple précédent de la pile de fonctions pour illustrer cela :

function fonctionA() {
    console.log('Début de fonctionA');
    fonctionB();
    console.log('Fin de fonctionA');
}

function fonctionB() {
    console.log('Début de fonctionB');
    fonctionC();
    console.log('Fin de fonctionB');
}

function fonctionC() {
    console.log('Début de fonctionC');
    console.log('Fin de fonctionC');
}

fonctionA();

Exécution et Pile de Fonctions

1. Appel de fonctionA() :

   • fonctionA est ajoutée à la pile.
   • La pile contient : [fonctionA]
   • Console : Début de fonctionA

2. fonctionA appelle fonctionB() :

   • fonctionB est ajoutée à la pile.
   • La pile contient : [fonctionA, fonctionB]
   • Console : Début de fonctionB

3. fonctionB appelle fonctionC() :

   • fonctionC est ajoutée à la pile.
   • La pile contient : [fonctionA, fonctionB, fonctionC]
   • Console : Début de fonctionC
   • Console : Fin de fonctionC

4. Retour de fonctionC à fonctionB :

   • fonctionC est retirée de la pile.
   • La pile contient : [fonctionA, fonctionB]
   • Console : Fin de fonctionB

5. Retour de fonctionB à fonctionA :

   • fonctionB est retirée de la pile.
   • La pile contient : [fonctionA]
   • Console : Fin de fonctionA

6. Fin de fonctionA :

   • fonctionA est retirée de la pile.
   • La pile est maintenant vide.

function premiere() {
    console.log('Première fonction');
    seconde();
    console.log('Retour à la première fonction');
}

function seconde() {
    console.log('Deuxième fonction');
}

premiere();

Lorsque vous exécutez premiere(), voici ce qui se passe :

1. premiere() est appelée et ajoutée à la pile.
2. premiere() appelle seconde(), qui est ajoutée à la pile au-dessus de premiere().
3. seconde() s’exécute et est retirée de la pile.
4. Le contrôle revient à premiere(), qui termine son exécution et est retirée de la pile.

Ce mécanisme vous permet de suivre l’ordre d’exécution des fonctions et d’assurer que chaque fonction termine son travail avant de passer à la suivante.

Voici un exemple de Dépassement de la Pile

Un dépassement de pile (stack overflow) se produit lorsque la pile est saturée, souvent à cause de récursions infinies 

function recursive() {
    recursive(); // Appel infini
}

recursive(); // Dépassement de la pile

Pourquoi dois je connaître cela ?

Maîtriser la portée d’une fonction et la pile de fonctions est essentiel pour écrire un code JavaScript sans bug et performant pour tes programmes.

Ces concepts t’aide à comprendre où tes fonctions sont accessibles et comment les fonctions sont exécutées.