DIV CSS 佈局教程網

JavaScript ES6 的 let 命令完整用法解析
編輯:JavaScript基礎知識     

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 根本還不存在,用到它就是錯誤。

暫時性死區(TDZ)

只要塊級作用域內存在 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 只是控制迴圈用的,迴圈結束後卻還留在全域。

ES6 的塊級作用域

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() {}

do 表達式(提案)

本質上,塊級作用域是一個語句,把多個操作封裝在一起,本身沒有返回值:

{
  let t = f();
  t = t * t + 1;
}

區塊外拿不到 t 的值,除非它是全域變數。有個提案主張在區塊前加上 do,讓它變成可以回傳值的表達式:

let x = do {
  let t = f();
  t * t + 1;
};

這樣 x 就會得到整個塊級作用域的回傳值。

let 與 var 的比較

全域(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 的作用域是最近的塊級作用域(不在任何區塊中則為全域),範圍更小、更可控。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved