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 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(); // 报错
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]
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; }
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; // 不报错 } }
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. 🎜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
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 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. 🎜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
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 }
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'}}}}};
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); // 报错 }}}};
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只用来控制循环,但是循环结束后,它并没有消失,泄露成了全局变量。
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!