let 是 ES6 新增的變數宣告方式。它看起來像 var,但作用域規則完全不同,理解它幾乎等於理解 ES6 塊級作用域的一半。
{
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 只在迴圈體內存在,迴圈外引用就會報錯。
如果把 let 換成 var,最後輸出會是 10:
var a = [];
for (var i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 10
因為 var 宣告的 i 在全域都有效,每一輪的新值都覆蓋舊值,最後自然只剩下迴圈結束時的值。
改用 let 之後,輸出變成 6:
var a = [];
for (let i = 0; i < 10; i++) {
a[i] = function () {
console.log(i);
};
}
a[6](); // 6
此時 i 只在當前這一輪迴圈有效,每一次迭代的 i 其實都是新變數,因此每個閉包各自記住了自己的值。
console.log(foo); // undefined console.log(bar); // ReferenceError var foo = 2; let bar = 2;
var 會發生變數提升:腳本開始執行時 foo 已存在但沒有值,所以印出 undefined。let 不會提升,代表在宣告語句執行之前,bar 根本還不存在,用到它就是錯誤。
只要塊級作用域內存在 let 宣告,它宣告的變數就會「綁定」這個區域,不再受外部影響。
var tmp = 123;
if (true) {
tmp = 'abc'; // ReferenceError
let tmp;
}
全域雖然有 tmp,但區塊內的 let tmp 讓後者綁定了這個塊級作用域,所以在宣告之前對 tmp 賦值就會報錯。
ES6 明確規定:區塊中若存在 let 或 const,這些變數從區塊一開始就形成封閉作用域,凡在宣告之前使用它們,都會報錯。這段「宣告前不可用」的區間,就稱為暫時性死區。
if (true) {
// TDZ 開始
tmp = 'abc'; // ReferenceError
console.log(tmp); // ReferenceError
let tmp; // TDZ 結束
console.log(tmp); // undefined
tmp = 123;
console.log(tmp); // 123
}
暫時性死區也意味著 typeof 不再是百分之百安全的操作:
typeof x; // ReferenceError let x;
對照之下,若變數從未宣告過,typeof 反而不會報錯:
typeof undeclared_variable // "undefined"
在沒有 let 的年代,typeof 永遠不會出錯;現在這個前提被打破了。這樣設計的目的,是逼大家養成「先宣告、後使用」的習慣。
有些死區相當隱蔽:
function bar(x = y, y = 2) {
return [x, y];
}
bar(); // 報錯
報錯原因是參數 x 的預設值參考了 y,而此時 y 尚未宣告,正處於死區。反過來寫就不會有問題:
function bar(x = 2, y = x) {
return [x, y];
}
bar(); // [2, 2]
ES6 之所以取消變數提升、引入暫時性死區,主要是為了減少執行期錯誤,避免在宣告前使用變數導致意料之外的行為——這類問題在 ES5 時代非常常見。
// 報錯
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
輸出 undefined 而非日期,是因為變數提升讓內層的 tmp 覆蓋了外層。
第二種:計數用的迴圈變數洩漏成全域變數。
var s = 'hello';
for (var i = 0; i < s.length; i++) {
console.log(s[i]);
}
console.log(i); // 5
i 只是控制迴圈用的,迴圈結束後卻還留在全域。
function f1() {
let n = 5;
if (true) {
let n = 10;
}
console.log(n); // 5
}
內外兩個程式碼塊各自宣告了 n,輸出 5 表示外層不受內層影響;若改用 var,結果會是 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 = ...;
...
}
函數能不能在塊級作用域中宣告,一直是個容易混淆的問題。ES5 規定函數只能在頂層作用域與函數作用域中宣告:
// 情況一
if (true) {
function f() {}
}
// 情況二
try {
function f() {}
} catch (e) {}
依 ES5 規範,這兩種寫法都是非法的。但瀏覽器為了相容舊碼,實際上允許這樣寫,只有在嚴格模式下才會報錯:
// ES5 嚴格模式
'use strict';
if (true) {
function f() {}
} // 報錯
ES6 引入塊級作用域後,明確允許在塊級作用域中宣告函數:
// ES6 嚴格模式
'use strict';
if (true) {
function f() {}
} // 不報錯
ES6 規定,塊級作用域內的函數宣告行為類似 let,區塊外無法引用:
function f() { console.log('I am outside!'); }
(function () {
if (false) {
// 重複宣告一次函數 f
function f() { console.log('I am inside!'); }
}
f();
}());
在 ES5 中這段程式碼輸出「I am inside!」,因為 if 內的函數宣告被提升到函數頂部,實際等同於:
// ES5 版本
function f() { console.log('I am outside!'); }
(function () {
function f() { console.log('I am inside!'); }
if (false) {}
f();
}());
ES6 的結果完全不同,會輸出「I am outside!」,因為塊級作用域內的函數宣告對外部沒有影響,實際等同於:
// ES6 版本
function f() { console.log('I am outside!'); }
(function () {
f();
}());
這種行為差異對舊程式碼衝擊不小,因此 ES6 在附錄 B 中允許瀏覽器的實現自行其是,具體規則為:
· 允許在塊級作用域內宣告函數;
· 函數宣告類似 var,會提升到全域或函數作用域頂部;
· 同時,函數宣告也會提升到所在塊級作用域的頂部。
注意這三條只對 ES6 的瀏覽器實現有效,其他環境仍把塊級作用域的函數宣告當作 let 處理。因此前面那段程式碼在 Chrome 環境下會報錯:
// ES6 的瀏覽器環境
function f() { console.log('I am outside!'); }
(function () {
if (false) {
function f() { console.log('I am inside!'); }
}
f();
}()); // Uncaught TypeError: f is not a function
原因在於實際執行的等同於:
// ES6 的瀏覽器環境
function f() { console.log('I am outside!'); }
(function () {
var f = undefined;
if (false) {
function f() { console.log('I am inside!'); }
}
f();
}()); // Uncaught TypeError: f is not a function
由於環境差異太大,實務上應該避免在塊級作用域內宣告函數。若確有必要,請寫成函數表達式:
// 函數宣告語句
{
let a = 'secret';
function f() { return a; }
}
// 函數表達式
{
let a = 'secret';
let f = function () { return a; };
}
另外,塊級作用域允許宣告函數的規則只在使用大括號時成立,省略大括號就會報錯:
// 不報錯
'use strict';
if (true) { function f() {} }
// 報錯
'use strict';
if (true) function f() {}
本質上,塊級作用域是一個語句,把多個操作封裝在一起,本身沒有返回值:
{
let t = f();
t = t * t + 1;
}
區塊外拿不到 t 的值,除非它是全域變數。有個提案主張在區塊前加上 do,讓它變成可以回傳值的表達式:
let x = do {
let t = f();
t * t + 1;
};
這樣 x 就會得到整個塊級作用域的回傳值。
全域(Global)在函數體之外,兩者等價:
let me = 'go'; // 全域作用域 var i = 'able'; // 全域作用域
函數(Function)在函數體內部,兩者也等價:
function ingWithinEstablishedParameters() {
let terOfRecommendation = 'awesome worker!'; // 函數區塊作用域
var sityCheerleading = 'go!'; // 函數區塊作用域
};
區塊(Block)這裡才是差異所在——let 只在 for 迴圈內可見,var 則整個函數都看得到:
function allyIlliterate() {
// tuce 在這裡看不到
for (let tuce = 0; tuce < 5; tuce++) {
// tuce 只在這裡(以及 for 的括號中)可見
}
// tuce 在這裡看不到
};
function byE40() {
// nish 在這裡可見
for (var nish = 0; nish < 5; nish++) {
// nish 對整個函數都是可見的
}
// nish 在這裡可見
};
總結一句:差別就在作用域。 var 的作用域是最近的函數作用域(不在函數中則為全域),let 的作用域是最近的塊級作用域(不在任何區塊中則為全域),範圍更小、更可控。