So verwenden Sie let in es6

In es6 wird das Schlüsselwort let zum Deklarieren von Variablen verwendet. Die deklarierten Variablen sind jedoch nur innerhalb des Codeblocks gültig, in dem sich der let-Befehl befindet. Let verursacht keine „Variablenheraufstufung“, daher müssen Variablen nach der Deklaration verwendet werden, andernfalls wird ein Fehler gemeldet. Solange der let-Befehl im Bereich auf Blockebene existiert, sind die von ihm deklarierten Variablen an diesen Bereich „bindend“ und werden nicht mehr von äußeren Einflüssen beeinflusst.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, ECMAScript Version 6, Dell G3-Computer.

es6 Schlüsselwort let

ES6 fügt einen neuen let-Befehl zum Deklarieren von Variablen hinzu. Seine Verwendung ähnelt der von var, die deklarierte Variable ist jedoch nur innerhalb des Codeblocks gültig, in dem sich der Befehl let befindet. 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(); // 报错

Der obige Code befindet sich im Codeblock und deklariert zwei Variablen mit let bzw. var. Dann werden diese beiden Variablen außerhalb des Codeblocks aufgerufen. Als Ergebnis meldet die mit let deklarierte Variable einen Fehler und die mit var deklarierte Variable gibt den korrekten Wert zurück. Dies zeigt, dass die mit let deklarierte Variable nur in dem Codeblock gültig ist, in dem sie sich befindet.

for Schleifenzähler, es ist sehr gut geeignet, den Befehl let zu verwenden. 🎜

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

🎜Im obigen Code ist der Zähler i nur innerhalb des Körpers der for-Schleife gültig und es wird ein Fehler gemeldet, wenn außerhalb der Schleife darauf verwiesen wird. 🎜🎜Wenn der folgende Code var verwendet, ist die endgültige Ausgabe 10. 🎜

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

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

🎜Im obigen Code wird die Variable i durch var deklariert und ist im globalen Bereich gültig. Bei jeder Schleife überschreibt der neue i-Wert den alten Wert, sodass die endgültige Ausgabe der Wert der letzten Runde von i ist. 🎜🎜Wenn Sie let verwenden, ist die deklarierte Variable nur innerhalb des Bereichs auf Blockebene gültig und die endgültige Ausgabe ist 6. 🎜

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

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

🎜Im obigen Code wird die Variable i durch let deklariert. Das aktuelle i ist nur in diesem Zyklus gültig, also in jedem Zyklus i ist eigentlich eine neue Variable, daher ist die endgültige Ausgabe 6. 🎜

🎜Keine variable Promotion🎜

🎜let verursacht keine „variable Promotion“ wie var. Daher müssen Variablen nach der Deklaration verwendet werden, andernfalls wird ein Fehler gemeldet. 🎜

var tmp = new Date();

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

f(); // undefined

🎜Im obigen Code wird die Variable foo mit dem Befehl var deklariert. Das heißt, wenn das Skript ausgeführt wird, wird die Variable foo existiert bereits, aber es gibt keinen Wert, daher wird undefiniert ausgegeben. Die Variable bar wird mit dem Befehl let deklariert und es findet keine Variablenheraufstufung statt. Dies bedeutet, dass die Variable bar vor der Deklaration nicht vorhanden ist und bei Verwendung ein Fehler ausgegeben wird. 🎜

🎜Temporäre Totzone🎜

🎜Solange der Befehl let im Bereich auf Blockebene vorhanden ist, sind die von ihm deklarierten Variablen „gebunden“. „(verbindlich) Dieser Bereich ist nicht mehr von äußeren Einflüssen betroffen. 🎜

var s = 'hello';

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

console.log(i); // 5

🎜Im obigen Code gibt es eine globale Variable tmp, aber let deklariert eine lokale Variable tmp im Bereich auf Blockebene. Dies führt zu Letzterem. Dieser Bereich auf Blockebene ist gebunden. Wenn Sie also tmp einen Wert zuweisen, bevor let die Variable deklariert, wird ein Fehler gemeldet. 🎜🎜ES6 legt eindeutig fest, dass, wenn in einem Block die Befehle let und const vorhanden sind, die von diesen Befehlen in diesem Block deklarierten Variablen von Anfang an einen geschlossenen Bereich bilden. Jede Verwendung dieser Variablen vor der Deklaration führt zu einem Fehler. 🎜🎜Kurz gesagt, innerhalb des Codeblocks ist die Variable erst verfügbar, wenn sie mit dem let-Befehl deklariert wird. Grammatisch wird dies als „temporäre Totzone“ (TDZ) bezeichnet. 🎜

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

🎜Bevor der Befehl let im obigen Code die Variable tmp deklariert, gehört sie zur „toten Zone“ der Variablen tmp . 🎜🎜 „Vorübergehende tote Zone“ bedeutet auch, dass typeof kein 100 % sicherer Betrieb mehr ist. 🎜

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

🎜Im obigen Code wird die Variable x mit dem Befehl let deklariert, sodass sie vor ihrer Deklaration zur „toten Zone“ von gehört x Solange Bei Verwendung dieser Variablen wird ein Fehler gemeldet. Daher wird ein ReferenceError ausgelöst, wenn typeof ausgeführt wird. 🎜🎜Zum Vergleich: Wenn eine Variable überhaupt nicht deklariert ist, wird bei Verwendung von typeof kein Fehler gemeldet. 🎜

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

🎜Im obigen Code ist undeclared_variable ein Variablenname, der nicht existiert, und das Ergebnis ist „undefiniert“. Bevor let existierte, war der Operator typeof daher 100 % sicher und meldete niemals einen Fehler. Das stimmt nicht mehr. Dieses Design soll jedem helfen, gute Programmiergewohnheiten zu entwickeln. Variablen müssen nach ihrer Deklaration verwendet werden, andernfalls wird ein Fehler gemeldet. 🎜🎜Einige „tote Zonen“ sind versteckt und nicht leicht zu finden. 🎜

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视频教程、编程视频】

Das obige ist der detaillierte Inhalt vonSo verwenden Sie let in es6. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!