Heim >Web-Frontend >Front-End-Fragen und Antworten >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 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. 🎜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. 🎜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只用来控制循环,但是循环结束后,它并没有消失,泄露成了全局变量。
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!