Quelle est la portée des variables en JavaScript ?

Question

Quelle est la portée des variables en JavaScript ? Ont-ils la même portée à l’intérieur et à l’extérieur de la fonction ? Ou est-ce important ? De plus, si les variables sont définies globalement, où sont-elles stockées ?

Answer 1

Javascript utilise des chaînes de portée pour déterminer la portée d'une fonction donnée. Il existe généralement une portée globale et chaque fonction définie a sa propre portée imbriquée. Toute fonction définie dans une autre fonction a une portée locale liée à la fonction externe. Il s'agit toujours de l'emplacement du code source où la portée est définie.

Un élément dans une chaîne de portées est essentiellement une carte avec un pointeur vers sa portée parent.

Lors de l'analyse des variables, JavaScript part de la portée la plus interne et recherche vers l'extérieur.

Answer 2

TLDR

JavaScript a une portée et des fermetures lexicales (également appelées statiques). Cela signifie que vous pouvez déterminer la portée d'un identifiant en examinant le code source.

Les quatre périmètres sont les suivants :

1. Global - visible par tous les contenus
2. Fonction - Visible à l'intérieur d'une fonction (et à l'intérieur de ses sous-fonctions et blocs)
3. Bloc - Visible à l'intérieur d'un bloc (et à l'intérieur de ses sous-blocs)
4. Modules - Visibles à l'intérieur des modules

Sauf les cas particuliers de portée globale et de module, les variables sont déclarées en utilisant var（函数作用域）、let（块作用域）和const (portée de bloc). En mode strict, la plupart des autres formes de déclarations d'identifiant ont une portée de bloc.

Aperçu

Scope est la zone de la base de code où l'identifiant est valide.

L'environnement lexical est le mappage entre les noms d'identifiants et les valeurs qui leur sont associées.

Une portée est formée par une imbrication liée d'environnements lexicaux, chaque niveau d'imbrication correspondant à l'environnement lexical d'un contexte d'exécution ancêtre.

Ces environnements lexicaux liés forment une « chaîne » de portée. La résolution d'identifiant est le processus de recherche tout au long de cette chaîne d'un identifiant correspondant.

La résolution des identifiants se fera uniquement vers l'extérieur. De cette façon, l’environnement lexical externe ne peut pas « voir » l’environnement lexical interne.

Il y a trois facteurs pertinents pour décider de la portée des identifiants en JavaScript :

1. Comment déclarer les identifiants
2. Position de déclaration de l'identifiant
3. Que ce soit en mode strict ou en mode non strict

Quelques façons de déclarer les identifiants :

1. var，let和const
2. Paramètres de fonction
3. paramètres du bloc de capture
4. Déclaration de fonction
5. Expression de fonction nommée
6. Propriétés implicitement définies sur les objets globaux (c'est-à-dire omises var en mode non strict)
7. importDéclaration
8. eval

Localisation de déclaration de certains identifiants :

1. Contexte mondial
2. Corps de fonction
3. Blocage normal
4. Le sommet d'une structure de contrôle (par exemple boucle, if, while, etc.)
5. Structure de contrôle
6. Module

Style de déclaration

var

Les identifiants var声明的标识符具有函数作用域，除非它们直接在全局上下文中声明，此时它们将作为全局对象的属性添加，并具有全局作用域。它们在eval déclarés à l'aide de

ont une portée de fonction

à moins qu'ils ne soient déclarés directement dans le contexte global, auquel cas ils sont ajoutés en tant que propriétés de l'objet global et ont une portée globale. Il existe des règles distinctes pour leur utilisation dans les fonctions

.

let和constlet et const Les identifiants

déclarés à l'aide de 🎜 ont une portée de bloc 🎜 à moins qu'ils ne soient déclarés directement dans le contexte global, auquel cas ils ont une portée globale. 🎜

Remarque : let，const和var都被提升。这意味着它们的逻辑定义位置是其封闭作用域（块或函数）的顶部。但是，使用let和constLes variables déclarées ne peuvent pas être lues ou attribuées tant que le flux de contrôle n'a pas traversé le point de déclaration dans le code source. Cette période temporaire est appelée zone morte temporaire.

function f() {
    function g() {
        console.log(x)
    }
    let x = 1
    g()
}
f() // 1 because x is hoisted even though declared with `let`!