Que signifie la zone morte temporaire es6 ?

Dans es6, la zone morte temporaire est une erreur de syntaxe, ce qui signifie que les commandes let et const font que le bloc forme une portée fermée. Dans un bloc de code, avant qu'une variable ne soit déclarée à l'aide de la commande let/const, la variable est indisponible et appartient à la « zone morte » de la variable avant que la variable ne soit déclarée ; c'est ce qu'on appelle syntaxiquement une « zone morte temporaire ». ES6 stipule que la promotion des variables ne se produit pas dans les zones mortes temporaires et dans les instructions let et const, principalement pour réduire les erreurs d'exécution et empêcher l'utilisation de la variable avant qu'elle ne soit déclarée, ce qui entraîne un comportement inattendu.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.

Qu'est-ce qu'une zone morte temporaire ?

Dans ES6, dans un bloc de code, avant qu'une variable ne soit déclarée à l'aide de la commande let/const, la variable est indisponible. Avant que la variable ne soit déclarée, elle appartient au. "zone morte" de la variable ". Grammaticalement, cela s'appelle la « zone morte temporaire » (TDZ). La norme ES ne mentionne pas explicitement TDZ, mais nous l'utilisons souvent pour décrire l'effet non amélioré de let et const.

La différence entre let/const et var

Avant ES6, il n'y avait que deux types de portées JS, la portée globale et la portée de fonction. Cependant, dans ES6, la portée au niveau du bloc est apparue, c'est-à-dire let/. const a été utilisé. La portée au niveau du bloc peut être définie. Ainsi, parmi les nouvelles fonctionnalités d'ES6, le moyen le plus simple de voir le rôle de TDZ consiste à utiliser let/const. Il existe deux différences principales entre let/const et var :

• let/const utilise la portée du bloc ; var utilise la portée de la fonction
• Si vous accédez aux variables et constantes correspondantes avant que let/const ne soit déclaré, une erreur ReferenceError se produit. ; mais si vous accédez à la variable correspondante avant que var soit déclaré, vous obtiendrez undéfini

console.log(Vname); // undefined;
console.log(Lname); // ReferenceError
var Vname = 'xiaoxiao';
let Lname = 'xiaoxiao';

La pratique a prouvé que lorsque nous utilisons des variables définies par var avant de déclarer, nous obtiendrons undéfini, mais lorsque nous utilisons des variables non définies par let, cela lancera une erreur. Parce que les variables déclarées par let dans ES6 n'ont pas d'effet de promotion de variable.

var x = 10;
if (true) {
    x = 20; // ReferenceError
    let x;
 }

ES6 stipule clairement que s'il y a des commandes let et const dans un bloc, les variables déclarées par ces commandes dans ce bloc formeront dès le début une portée fermée. Toute utilisation de ces variables avant déclaration entraînera une erreur. En bref, dans le bloc de code, la variable n'est disponible que lorsqu'elle est déclarée à l'aide de la commande let. Grammaticalement, cela s'appelle la « zone morte temporaire » (TDZ).

if (true) {
  // TDZ开始
  tmp = 'abc'; // ReferenceError
  console.log(tmp); // ReferenceError

  let tmp; // TDZ结束
  console.log(tmp); // undefined

  tmp = 123;
  console.log(tmp); // 123
}

Dans le code ci-dessus, avant que la commande let ne déclare la variable tmp, elle appartient à la "zone morte" de la variable tmp.

Le piège de la "zone morte" de typeof

Nous savons tous que l'utilisation de typeof peut être utilisée pour détecter le type de données d'une variable donnée, et peut également être utilisée pour déterminer si une valeur est définie. Lorsqu'undéfini est renvoyé, cela signifie que la valeur n'est pas définie ; Mais pour les variables définies par const/let, si typeof est utilisé avant que la variable ne soit déclarée, une erreur sera signalée

typeof x; // ReferenceError
let x;

Parce que x est déclaré en utilisant let, alors c'est une zone morte temporaire avant que x ne soit déclaré, et une erreur sera être signalé lors de l'utilisation de typeof . Par conséquent, les variables déclarées à l’aide de let/const ne sont pas nécessairement sûres lors de l’utilisation de typeof.

typeof y; // 'undefined'

Mais on peut voir que si nous utilisons simplement typeof sans le définir, aucune erreur ne sera signalée. De là, nous pouvons voir que tant qu'il n'y a pas de disposition claire pour utiliser la définition const/let, il n'y aura pas d'erreur. .

Le piège de la "zone morte" du passage des paramètres

Par exemple, dans le morceau de code suivant, nous utilisons

function bar(x = y, y = 2) {
  return [x, y];
}

bar(); // 报错

Dans le code ci-dessus, la raison pour laquelle l'appel de la fonction bar signale une erreur (certains les implémentations peuvent ne pas signaler d'erreur) est dû au paramètre x. La valeur par défaut est égale à un autre paramètre y, qui n'a pas encore été déclaré et appartient à la "zone morte". Si la valeur par défaut de y est x, aucune erreur ne sera signalée car x a été déclaré à ce moment-là.

function bar(x = 2, y = x) {
  return [x, y];
}
bar(); // [2, 2]

Une autre différence entre l'utilisation des déclarations var et let.

// 不报错
var x = x;

// 报错
let x = x;
// ReferenceError: x is not defined

Affecté par la "zone morte", lors de l'utilisation de let pour déclarer une variable, tant que la variable est utilisée avant que la déclaration ne soit terminée, une erreur sera signalée. La ligne ci-dessus appartient à cette situation. Avant que l'instruction de déclaration de la variable x ne soit exécutée, la valeur de x est obtenue, ce qui entraîne une erreur "x n'est pas défini".

Résumé

ES6 stipule que la promotion de variable ne se produit pas dans les zones mortes temporaires et dans les instructions let et const, principalement pour réduire les erreurs d'exécution et empêcher l'utilisation de la variable avant qu'elle ne soit déclarée, ce qui entraîne un comportement inattendu. Des erreurs comme celle-ci sont très courantes dans ES5, et maintenant que cette disposition est en place, il est facile de les éviter.

En bref, l'essence de la zone morte temporaire est que dès que vous entrez dans la portée actuelle, la variable que vous souhaitez utiliser existe déjà, mais elle n'est pas disponible. Vous ne pouvez obtenir et utiliser la variable que jusqu'à la ligne de. le code qui déclare la variable apparaît.

Remarque : TDZ a été conçu à l'origine pour const, mais plus tard, la conception pour let était également cohérente.

Remarque : Dans le standard ES6, les identifiants déclarés pour const sont encore souvent des variables, appelées variables constantes. Les constantes créées avec les déclarations const ne peuvent pas être réaffectées dans JS, mais elles ne sont pas immuables. Il existe encore une grande différence entre les deux concepts.

【Recommandations associées : tutoriel vidéo javascript, front-end web】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!