1. Qu'est-ce que le levage en JavaScript ?

Réponse : Le levage est le processus pendant la phase de création du contexte d'exécution où la mémoire est allouée aux variables et aux fonctions. Au cours de ce processus, la mémoire des variables est allouée et les variables se voient attribuer la valeur indéfinie. Pour les fonctions, la définition complète de la fonction est stockée à une adresse spécifique en mémoire et une référence à celle-ci est placée sur la pile dans ce contexte d'exécution particulier.

2. Quelle est la différence entre le levage variable et le levage fonctionnel ?

Réponse : Le levage de variable se produit lorsque la déclaration d'une variable est déplacée vers le haut de sa portée. D'un autre côté, le levage d'une fonction se produit lorsque la fonction entière, y compris son corps, est déplacée vers le haut de sa portée.

3. Comment fonctionne le levage en JavaScript ?

Réponse : Le levage est un mécanisme JavaScript dans lequel les déclarations de variables et de fonctions sont déplacées vers le haut de leur portée avant le début de l'exécution du code. Grâce au levage, nous pouvons utiliser des variables avant qu'elles ne soient déclarées.

• Histage de variable : Lorsqu'une variable est déclarée, elle est déplacée vers le haut de sa portée, et nous pouvons utiliser cette variable avant même sa déclaration dans le code.

• Hissage de fonction : Lorsqu'une fonction est levée, l'intégralité du corps de la fonction est déplacée vers le haut de sa portée. Cela signifie que nous pouvons appeler la fonction avant même sa déclaration dans le code.

4. Quelle est la valeur d’une variable déclarée mais non initialisée ?

Réponse : Si vous déclarez une variable mais ne lui attribuez pas de valeur, la variable est considérée comme n'ayant aucune valeur. JavaScript déplace la déclaration de variable vers le haut lors du levage, mais aucune valeur n'est encore attribuée à la variable. La variable est affectée de manière non définie, ce qui signifie qu'elle n'a encore reçu aucune valeur.

5. Que se passe-t-il si vous déclarez une variable deux fois dans la même portée ?

Réponse : Si vous déclarez la même variable deux fois dans la même portée, la deuxième déclaration écrasera la première et la valeur de la première déclaration sera remplacée par la seconde. Cela se produit parce que JavaScript stocke la première déclaration en mémoire et lorsqu'il rencontre la seconde, il écrase la valeur précédente.

6. Pouvez-vous extraire une variable sans utiliser le mot-clé var ?

Réponse : Oui, en JavaScript, vous pouvez extraire des variables en utilisant let ou const au lieu de var. Bien que var soit traditionnellement utilisé, il présente certains problèmes liés à la portée, c'est pourquoi il est recommandé d'utiliser let ou const.

Exemple avec let :

let myVariable = 42;
console.log(myVariable); // Output: 42

Exemple avec const :

const pi = 3.14159;
console.log(pi); // Output: 3.14159

Les variables déclarées avec let et const ont une portée au niveau du bloc, ce qui signifie qu'elles sont confinées au bloc (comme une fonction, une boucle ou une instruction) où elles sont définies. let permet la réaffectation, tandis que const est utilisé pour les constantes et ne peut pas être réaffecté.

7. Quelle est la différence entre une déclaration de fonction et une expression de fonction en termes de levage ?

Réponse : Une déclaration de fonction est hissée au sommet de sa portée, alors qu'une expression de fonction ne l'est pas. Cela signifie que vous pouvez appeler une fonction déclarée avec une déclaration de fonction avant sa définition, mais vous ne pouvez pas faire de même avec une expression de fonction.

8. Quelle est la portée d’une variable hissée ?

Réponse : La portée d'une variable hissée dépend de l'endroit où elle est déclarée. Si la variable est déclarée dans une fonction, sa portée est limitée à cette fonction, ce qui signifie qu'elle n'est pas accessible en dehors de celle-ci. Si une variable est déclarée en dehors de toute fonction, elle a une portée globale, ce qui signifie qu'elle est accessible depuis n'importe où dans le code.

9. Comment empêcher le levage en JavaScript ?

Réponse : Le levage ne peut pas être entièrement évité en JavaScript, mais vous pouvez écrire votre code de manière à éviter les problèmes potentiels qu'il provoque. Une façon de procéder consiste à déclarer toutes les variables et fonctions en haut de leur portée.

Dans les exemples de code ci-dessus, toutes les variables et fonctions sont déclarées en haut de leur bloc à l'aide de var ou let. Cela garantit que les variables et les fonctions sont hissées dans leur bloc et apparaissent en haut de leur portée.

Cette méthode rend le flux de code et les valeurs des variables plus prévisibles, ce qui contribue à réduire la variabilité et les bogues potentiels.

10. Quels sont les pièges potentiels du levage en JavaScript ?

Réponse : Le levage peut entraîner des problèmes potentiels si vous ne comprenez pas parfaitement son fonctionnement, ce qui entraîne des comportements inattendus. Par exemple, si vous déclarez une variable dans une instruction de bloc et essayez d'y accéder en dehors du bloc, la variable peut être hissée au sommet de la fonction ou de la portée globale, ce qui peut ne pas être ce que vous vouliez.

• Portée du bloc et levage : Les variables déclarées à l'intérieur d'un bloc peuvent toujours être hissées au sommet de leur portée.

• Difficulté de débogage : Le levage peut rendre le débogage difficile car la valeur ou la variable à laquelle vous essayez d'accéder peut ne pas se comporter comme prévu.

• bizarreries de définition des fonctions : Les fonctions sont hissées au sommet de leur portée, mais vous ne pouvez pas toujours les utiliser de la manière souhaitée.
  Pour résoudre ces problèmes de levage, il est important de déclarer clairement vos variables et fonctions et de comprendre comment fonctionne le levage dans votre code.

11. Le levage peut-il modifier l'ordre d'exécution en JavaScript ?

Réponse : Oui, le levage en JavaScript déplace les déclarations de variables et de fonctions en haut de leurs portées respectives avant le début de l'exécution du code. Cela peut modifier le flux attendu d'exécution du code.
Avec le levage, vous pouvez déclarer une variable et l'utiliser avant qu'elle ne soit réellement définie, ce qui peut modifier l'ordre attendu d'exécution du code et conduire à des résultats inattendus.
Par exemple, si vous ne définissez pas de fonctions au début du script et que vous les utilisez plus tard, elles seront hissées au sommet, créant potentiellement un flux et un comportement inattendus dans le code.

12. Quelle est la différence entre le levage dans les déclarations var et let ?

Réponse : les déclarations var sont hissées en haut de leur portée, tandis que les déclarations let sont hissées en haut de leur bloc. Cela signifie que les variables déclarées avec let ne sont pas accessibles en dehors de leur bloc.

Regardons un exemple pour clarifier ceci :

function example() {
    console.log(x); // undefined
    var x = 5;
    console.log(x); // 5
}
example();
console.log(x); // ReferenceError: x is not defined

Ici, var x = 5; est hissé au sommet du périmètre de la fonction. Cependant, lorsque console.log(x) est appelé avant la déclaration, la valeur n'est pas définie en raison du levage.

Regardons maintenant un exemple avec let :

function example() {
    console.log(y); // ReferenceError: y is not defined
    let y = 10;
    console.log(y); // 10
}
example();
console.log(y); // ReferenceError: y is not defined

Ici, soit y = 10 ; est hissé au sommet de sa portée de bloc, mais tenter d'y accéder avant sa déclaration entraîne une ReferenceError.

En résumé, les variables var sont hissées en haut de la portée de la fonction, tandis que les variables let sont hissées en haut de leur bloc.

13. Que se passe-t-il si vous essayez d'accéder à une variable hissée avant qu'elle ne soit déclarée ?

Réponse : Si vous essayez d'accéder à une variable hissée avant qu'elle ne soit déclarée, sa valeur ne sera pas définie.

14. Quel est le comportement de levage des fonctions fléchées en JavaScript ?

Réponse : Les fonctions fléchées ne sont pas hissées en JavaScript, vous ne pouvez donc pas appeler une fonction fléchée avant qu'elle ne soit définie.

// This will work
function regularFunction() {
    console.log("This is a regular function");
}
regularFunction(); // "This is a regular function"

// This will not work
arrowFunction(); // TypeError: arrowFunction is not a function
const arrowFunction = () => {
    console.log("This is an arrow function");
};

Ici, RegularFunction est hissé et peut être appelé avant sa définition, mais arrowFunction n'est pas hissé, donc l'appeler avant sa définition entraînera une erreur.

15. Le levage peut-il avoir lieu au sein d'une fonction ?

Réponse : Oui, le levage peut se produire au sein d'une fonction. Cela signifie que les variables ou fonctions déclarées à l’intérieur d’une fonction sont hissées au sommet de la portée de cette fonction.

16. Qu'est-ce que la chaîne de portée en JavaScript ?

Réponse : En JavaScript, la chaîne de portées est la hiérarchie des portées utilisée par le moteur JavaScript pour rechercher la valeur d'une variable. La chaîne de portée comprend la portée de la fonction actuelle, les portées des fonctions externes et la portée globale.

La chaîne de portée fonctionne comme un processus étape par étape pour trouver la valeur d'une variable. Si une variable ou une fonction est déclarée dans une fonction, le moteur JavaScript examine d'abord le périmètre de cette fonction. Si la valeur n'y est pas trouvée, il recherche la fonction externe et poursuit ce processus jusqu'à ce qu'il atteigne la portée globale.
De cette façon, JavaScript utilise la chaîne de portée pour rechercher les valeurs des variables et met à jour la chaîne en fonction de l'endroit où la variable est définie.

17. Quel sera le résultat de l’extrait de code suivant ?

Répondre:

console.log(a);
var a = 10;
Output: undefined

18. Quel sera le résultat de l’extrait de code suivant ?

Répondre:
ReferenceError : a n'est pas défini
Dans ce cas, a est déclaré en utilisant let, ce qui signifie qu'il n'est pas hissé au sommet de sa portée. Puisque a n'est pas défini avant l'instruction console.log(), une erreur de référence est générée.

19. Quel sera le résultat de l’extrait de code suivant ?

Répondre:

var a = 5;
(function() {
    console.log(a); // undefined
    var a = 10;
})();
Output: undefined

Pour bien comprendre ce processus, décomposons-le étape par étape :

Dans la première ligne, var a = 5; crée une variable a avec la valeur 5 dans la portée globale.
Ensuite, une expression de fonction immédiatement invoquée (IIFE) est définie et appelée.
À l'intérieur de la fonction, console.log(a); essaie d'imprimer la valeur de a. Cependant, comme var a = 10 ; est déclarée dans la fonction, la variable locale a est hissée hors de la portée de la fonction, mais sa valeur n'a pas encore été attribuée, elle s'imprime donc non définie.
Après cela, var a = 10 ; crée une nouvelle variable dans la portée locale avec la valeur de 10.
Ainsi, le premier console.log(a); s'imprime non défini en raison du levage, et après la déclaration, la valeur de a est mise à jour à 10.

20. Quel sera le résultat de l’extrait de code suivant ?

Répondre:

function test() {
  console.log(a);
  var a = 10;
  console.log(a);
}
test();
Output:
undefined
10

La fonction test() est définie avec deux instructions console.log() :

Dans le premier console.log(a); la variable a est déclarée dans la fonction mais n'a pas encore reçu de valeur, elle s'imprime donc non définie.
Dans la deuxième console.log(a); la variable a reçoit la valeur 10, qui est imprimée comme 10.
Ainsi, lorsque la fonction est appelée, le premier console.log(a); imprime undefined, et le deuxième console.log(a); imprime 10.