Comment utiliser let in es6

Dans es6, le mot-clé let est utilisé pour déclarer des variables ; cependant, les variables déclarées ne sont valides que dans le bloc de code où se trouve la commande let. Let ne provoque pas de "promotion de variable", les variables doivent donc être utilisées après leur déclaration, sinon une erreur sera signalée. Tant que la commande let existe dans la portée au niveau du bloc, les variables déclarées par celle-ci sont « liées » à cette zone et ne sont plus affectées par les influences externes.

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

es6 let keyword

ES6 ajoute une nouvelle commande let pour déclarer les variables. Son utilisation est similaire à var, mais la variable déclarée n'est valide que dans le bloc de code où se trouve la commande let. let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。

{
  let a = 10;
  var b = 1;
}

a // ReferenceError: a is not defined.
b // 1

上面代码在代码块之中，分别用let和var声明了两个变量。然后在代码块之外调用这两个变量，结果let声明的变量报错，var声明的变量返回了正确的值。这表明，let声明的变量只在它所在的代码块有效。

for循环的计数器，就很合适使用let命令。

for (let i = 0; i < 10; i++) {}

console.log(i);
//ReferenceError: i is not defined

上面代码中，计数器i只在for循环体内有效，在循环体外引用就会报错。

下面的代码如果使用var，最后输出的是10。

var a = [];
for (var i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 10

上面代码中，变量i是var声明的，在全局范围内都有效。所以每一次循环，新的i值都会覆盖旧值，导致最后输出的是最后一轮的i的值。

如果使用let，声明的变量仅在块级作用域内有效，最后输出的是6。

var a = [];
for (let i = 0; i < 10; i++) {
  a[i] = function () {
    console.log(i);
  };
}
a[6](); // 6

上面代码中，变量i是let声明的，当前的i只在本轮循环有效，所以每一次循环的i其实都是一个新的变量，所以最后输出的是6。

不存在变量提升

let不像var那样会发生“变量提升”现象。所以，变量一定要在声明后使用，否则报错。

console.log(foo); // 输出undefined
console.log(bar); // 报错ReferenceError

var foo = 2;
let bar = 2;

上面代码中，变量foo用var命令声明，会发生变量提升，即脚本开始运行时，变量foo已经存在了，但是没有值，所以会输出undefined。变量bar用let命令声明，不会发生变量提升。这表示在声明它之前，变量bar是不存在的，这时如果用到它，就会抛出一个错误。

暂时性死区

只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影响。

var tmp = 123;

if (true) {
  tmp = 'abc'; // ReferenceError
  let tmp;
}

上面代码中，存在全局变量tmp，但是块级作用域内let又声明了一个局部变量tmp，导致后者绑定这个块级作用域，所以在let声明变量前，对tmp赋值会报错。

ES6明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。

总之，在代码块内，使用let命令声明变量之前，该变量都是不可用的。这在语法上，称为“暂时性死区”（temporal dead zone，简称TDZ）。

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

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

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

上面代码中，在let命令声明变量tmp之前，都属于变量tmp的“死区”。

“暂时性死区”也意味着typeof不再是一个百分之百安全的操作。

typeof x; // ReferenceError
let x;

上面代码中，变量x使用let命令声明，所以在声明之前，都属于x的“死区”，只要用到该变量就会报错。因此，typeof运行时就会抛出一个ReferenceError。

作为比较，如果一个变量根本没有被声明，使用typeof反而不会报错。

typeof undeclared_variable // "undefined"

上面代码中，undeclared_variable是一个不存在的变量名，结果返回“undefined”。所以，在没有let之前，typeof

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

bar(); // 报错

Le code ci-dessus est dans le bloc de code et déclare deux variables en utilisant respectivement let et var. Ensuite, ces deux variables sont appelées en dehors du bloc de code. Par conséquent, la variable déclarée par let rapporte une erreur, et la variable déclarée par var renvoie la valeur correcte. Cela montre que la variable déclarée par let n'est valide que dans le bloc de code dans lequel elle se trouve.

Compteur de boucles for, il est très approprié d'utiliser la commande let. 🎜

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

🎜Dans le code ci-dessus, le compteur i n'est valide que dans le corps de la boucle for, et une erreur sera signalée lorsqu'il est référencé en dehors de la boucle. 🎜🎜Si le code suivant utilise var, le résultat final est 10. 🎜

// 报错
function () {
  let a = 10;
  var a = 1;
}

// 报错
function () {
  let a = 10;
  let a = 1;
}

🎜Dans le code ci-dessus, la variable i est déclarée par var et est valide dans la portée globale. Ainsi, à chaque boucle, la nouvelle valeur i écrasera l'ancienne valeur, ce qui fera que la sortie finale sera la valeur du dernier tour de i. 🎜🎜Si vous utilisez let, la variable déclarée n'est valide que dans la portée au niveau du bloc et le résultat final est 6. 🎜

function func(arg) {
  let arg; // 报错
}

function func(arg) {
  {
    let arg; // 不报错
  }
}

🎜Dans le code ci-dessus, la variable i est déclarée par let Le i actuel n'est valable que dans ce cycle, donc à chaque cycle. i est en fait une nouvelle variable, donc le résultat final est 6. 🎜

🎜Aucune promotion variable🎜

🎜let ne provoque pas de "promotion variable" comme var. Par conséquent, les variables doivent être utilisées après avoir été déclarées, sinon une erreur sera signalée. 🎜

var tmp = new Date();

function f() {
  console.log(tmp);
  if (false) {
    var tmp = "hello world";
  }
}

f(); // undefined

🎜Dans le code ci-dessus, la variable foo est déclarée avec la commande var. La promotion de la variable se produira, c'est-à-dire que lorsque le script commencera à s'exécuter, la variable foo existe déjà, mais il n'y a pas de valeur, donc <code>undefined sera affiché. La variable bar est déclarée avec la commande let, et aucune promotion de variable n'aura lieu. Cela signifie que la variable bar n'existe pas avant de la déclarer, et si elle est utilisée à ce moment, une erreur sera générée. 🎜

🎜Zone morte temporaire🎜

🎜Tant que la commande let existe dans la portée au niveau du bloc, les variables déclarées par celle-ci sont "liées " (contraignant) ce domaine n'est plus affecté par les influences extérieures. 🎜

var s = 'hello';

for (var i = 0; i < s.length; i++) {
  console.log(s[i]);
}

console.log(i); // 5

🎜Dans le code ci-dessus, il y a une variable globale tmp, mais let déclare une variable locale tmp dans la portée au niveau du bloc, ce qui entraîne ce dernier. Cette portée au niveau du bloc est limitée, donc attribuer une valeur à tmp avant que let déclare la variable signalera une erreur. 🎜🎜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 une « zone morte temporaire » (TDZ). 🎜

function f1() {
  let n = 5;
  if (true) {
    let n = 10;
  }
  console.log(n); // 5
}

🎜Dans le code ci-dessus, avant que la commande let déclare la variable tmp, elle appartient à la "zone morte" de la variable tmp . 🎜🎜 "Zone morte temporaire" signifie également que typeof n'est plus une opération sûre à 100 %. 🎜

{{{{{let insane = 'Hello World'}}}}};

🎜Dans le code ci-dessus, la variable x est déclarée à l'aide de la commande let, donc avant d'être déclarée, elle appartient à la "zone morte" de x. Tant qu'une erreur sera signalée lors de l'utilisation de cette variable. Par conséquent, une ReferenceError sera levée lors de l'exécution de typeof. 🎜🎜À titre de comparaison, si une variable n'est pas déclarée du tout, l'utilisation de typeof ne signalera pas d'erreur. 🎜

{{{{
  {let insane = 'Hello World'}
  console.log(insane); // 报错
}}}};

🎜Dans le code ci-dessus, undeclared_variable est un nom de variable qui n'existe pas, et le résultat est "indéfini". Par conséquent, avant que let n'existe, l'opérateur typeof était sûr à 100 % et ne signalerait jamais d'erreur. Ce n'est plus vrai. Cette conception vise à aider chacun à développer de bonnes habitudes de programmation. Les variables doivent être utilisées après leur déclaration, sinon une erreur sera signalée. 🎜🎜Certaines "zones mortes" sont cachées et difficiles à trouver. 🎜

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

bar(); // 报错

上面代码中，调用bar函数之所以报错（某些实现可能不报错），是因为参数x默认值等于另一个参数y，而此时y还没有声明，属于”死区“。如果y的默认值是x，就不会报错，因为此时x已经声明了。

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

ES6规定暂时性死区和let、const语句不出现变量提升，主要是为了减少运行时错误，防止在变量声明前就使用这个变量，从而导致意料之外的行为。这样的错误在ES5是很常见的，现在有了这种规定，避免此类错误就很容易了。

总之，暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获取和使用该变量。

不允许重复声明

let不允许在相同作用域内，重复声明同一个变量。

// 报错
function () {
  let a = 10;
  var a = 1;
}

// 报错
function () {
  let a = 10;
  let a = 1;
}

因此，不能在函数内部重新声明参数。

function func(arg) {
  let arg; // 报错
}

function func(arg) {
  {
    let arg; // 不报错
  }
}

块级作用域

为什么需要块级作用域？

ES5只有全局作用域和函数作用域，没有块级作用域，这带来很多不合理的场景。

第一种场景，内层变量可能会覆盖外层变量。

var tmp = new Date();

function f() {
  console.log(tmp);
  if (false) {
    var tmp = "hello world";
  }
}

f(); // undefined

上面代码中，函数f执行后，输出结果为undefined，原因在于变量提升，导致内层的tmp变量覆盖了外层的tmp变量。

第二种场景，用来计数的循环变量泄露为全局变量。

var s = 'hello';

for (var i = 0; i < s.length; i++) {
  console.log(s[i]);
}

console.log(i); // 5

上面代码中，变量i只用来控制循环，但是循环结束后，它并没有消失，泄露成了全局变量。

ES6的块级作用域

let实际上为JavaScript新增了块级作用域。

function f1() {
  let n = 5;
  if (true) {
    let n = 10;
  }
  console.log(n); // 5
}

上面的函数有两个代码块，都声明了变量n，运行后输出5。这表示外层代码块不受内层代码块的影响。如果使用var定义变量n，最后输出的值就是10。

ES6允许块级作用域的任意嵌套。

{{{{{let insane = 'Hello World'}}}}};

上面代码使用了一个五层的块级作用域。外层作用域无法读取内层作用域的变量。

{{{{
  {let insane = 'Hello World'}
  console.log(insane); // 报错
}}}};

内层作用域可以定义外层作用域的同名变量。

{{{{
  let insane = 'Hello World';
  {let insane = 'Hello World'}
}}}};

块级作用域的出现，实际上使得获得广泛应用的立即执行函数表达式（IIFE）不再必要了。

// IIFE 写法
(function () {
  var tmp = ...;
  ...
}());

// 块级作用域写法
{
  let tmp = ...;
  ...
}

【相关推荐：javascript视频教程、编程视频】

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!