ECMAScript 6(後來的正式名稱是 ECMAScript 2015)是 JavaScript 語言發展史上幅度最大的一次升級。它的目標很明確:讓 JavaScript 有能力承載大型應用、通用函式庫,甚至成為產生程式碼的程式碼生成器(code generator)。
好消息是,ES6 早已不是紙上規格。主流瀏覽器對它的支援推進得比當年 ES5 快得多,Chrome 與 Firefox 幾乎實作了絕大部分語法特性,日常開發已經可以大方使用。以下整理 17 個最關鍵的新語法,作為快速入門的路線圖。
let 帶來了真正的區塊級作用域。ES6 之後的慣例是:在函式內宣告變數優先用 let,而不是 var。
var a = 2;
{
let a = 3;
console.log(a); // 3
}
console.log(a); // 2
const 宣告的常量同樣只在所屬區塊內有效。要特別理解的是,它鎖定的是「綁定關係」而非「值本身」——比較接近一個指向某個參照的指標,所以內容仍然可以變動:
{
const ARR = [5, 6];
ARR.push(7);
console.log(ARR); // [5, 6, 7]
ARR = 10; // TypeError
}
幾個實務上容易踩到的重點:
let 沒有變數提升(hoisting)行為,在宣告前存取會踩到 Temporal Dead Zone。let 與 const 的作用範圍僅限最靠近的那一層大括號。CAPITAL_CASING。const 在宣告的同時就必須完成賦值。箭頭函式是函式的簡寫形式:一對括號包住參數,接著是 =>,後面是函式主體。
var getPrice = function () {
return 4.55;
};
// 使用箭頭函式的寫法
var getPrice = () => 4.55;
上面的例子採用的是簡潔函式主體,可以省略 return。若使用完整的區塊主體,就必須自己寫回傳:
let arr = ['apple', 'banana', 'orange'];
let breakfast = arr.map(fruit => {
return fruit + 's';
});
console.log(breakfast); // ['apples', 'bananas', 'oranges']
但箭頭函式的價值遠不只是少打幾個字,它真正的關鍵在於 this:箭頭函式沒有自己的 this,會沿用外層作用域的 this。看看傳統寫法遇到的困擾:
function Person() {
this.age = 0;
setInterval(function growUp() {
// 非嚴格模式下,growUp() 的 this 指向 window
this.age++;
}, 1000);
}
var person = new Person();
過去我們得先快取一份 this 再繞回來用:
function Person() {
var self = this;
self.age = 0;
setInterval(function growUp() {
self.age++;
}, 1000);
}
有了箭頭函式,這層彎路就消失了:
function Person() {
this.age = 0;
setInterval(() => {
// this 指向 person 物件
this.age++;
}, 1000);
}
var person = new Person();
參數預設值讓函式簽名更能自我說明:
let getFinalPrice = (price, tax = 0.7) => price + price * tax; getFinalPrice(500); // 850
... 到底是 Spread 還是 Rest,取決於它出現的位置。
用在迭代展開時,它是 Spread:
function foo(x, y, z) {
console.log(x, y, z);
}
let arr = [1, 2, 3];
foo(...arr); // 1 2 3
用在函式參數收集時,它是 Rest:
function foo(...args) {
console.log(args);
}
foo(1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]
宣告物件時,屬性可以簡寫,方法可以省略 function,屬性名稱甚至允許放運算式:
function getCar(make, model, value) {
return {
make, // 等同 make: make
model, // 等同 model: model
value, // 等同 value: value
['make' + make]: true, // 計算出的屬性名
depreciate() {
this.value -= 2500;
}
};
}
let car = getCar('Barret', 'Lee', 40000);
// {
// make: 'Barret',
// model: 'Lee',
// value: 40000,
// makeBarret: true,
// depreciate: function () {}
// }
數字前加上 0o 表示八進位,加上 0b 表示二進位:
let oValue = 0o10; console.log(oValue); // 8 let bValue = 0b10; console.log(bValue); // 2
解構可以省掉一堆中間變數:
function foo() {
return [1, 2, 3];
}
let [a, b, c] = foo();
console.log(a, b, c); // 1 2 3
function bar() {
return { x: 4, y: 5, z: 6 };
}
let { x, y, z } = bar();
console.log(x, y, z); // 4 5 6
物件也可以透過 super 呼叫原型上的方法:
var parent = {
foo() {
console.log("Hello from the Parent");
}
};
var child = {
foo() {
super.foo();
console.log("Hello from the Child");
}
};
Object.setPrototypeOf(child, parent);
child.foo();
// Hello from the Parent
// Hello from the Child
用反引號當分隔符,${ } 裡面放運算式,字串拼接終於變得可讀:
let user = 'Barret';
console.log(`Hi ${user}!`); // Hi Barret!
for...of 走的是迭代器,適合遍歷陣列這類可迭代物件:
let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname of nicknames) {
console.log(nickname);
}
// di, boo, punkeye
for...in 走的是鍵名,會連自訂屬性一起列出:
let nicknames = ['di', 'boo', 'punkeye'];
nicknames.size = 3;
for (let nickname in nicknames) {
console.log(nickname);
}
// 0, 1, 2, size
某種意義上,每個物件都是一個 Map,只是過去鍵只能是字串。ES6 的 Map 允許任何型別作為鍵:
var myMap = new Map();
var keyString = "a string";
var keyObj = {};
var keyFunc = function () {};
myMap.set(keyString, "value 與 'a string' 關聯");
myMap.set(keyObj, "value 與 keyObj 關聯");
myMap.set(keyFunc, "value 與 keyFunc 關聯");
myMap.size; // 3
myMap.get(keyString); // "value 與 'a string' 關聯"
myMap.get(keyObj); // "value 與 keyObj 關聯"
myMap.get(keyFunc); // "value 與 keyFunc 關聯"
WeakMap 的所有鍵都是弱參照,垃圾回收時不會把這些參照計入考量,因此不必擔心記憶體洩漏。代價是鍵必須是物件,而且只提供 delete、has、get、set 四個方法,無法走訪:
let w = new WeakMap();
w.set('a', 'b'); // Uncaught TypeError: Invalid value used as weak map key
var o1 = {}, o2 = function () {}, o3 = window;
w.set(o1, 37);
w.set(o2, "azerty");
w.set(o3, undefined);
w.get(o3); // undefined,就是當初設定的值
w.has(o1); // true
w.delete(o1);
w.has(o1); // false
Set 是一組不重複的值,重複者自動忽略,值可以是原始型別也可以是參照型別:
let mySet = new Set([1, 1, 2, 2, 3, 3]);
mySet.size; // 3
mySet.has(1); // true
mySet.add('strings');
mySet.add({ a: 1, b: 2 });
走訪可以用 forEach 或 for...of:
mySet.forEach((item) => {
console.log(item);
// 1
// 2
// 3
// 'strings'
// Object { a: 1, b: 2 }
});
for (let value of mySet) {
console.log(value);
}
此外還有 delete() 與 clear()。
WeakSet 保存物件的弱參照,同一個物件只能存在一次:
var ws = new WeakSet();
var obj = {};
var foo = {};
ws.add(window);
ws.add(obj);
ws.has(window); // true
ws.has(foo); // false,foo 沒有加入成功
ws.delete(window);
ws.has(window); // false,window 已被刪除
ES6 的 class 並不是新的繼承模型,它只是原型鏈的語法糖。用 static 可以定義屬於建構函式本身的成員:
class Task {
constructor() {
console.log("task instantiated!");
}
showId() {
console.log(23);
}
static loadAll() {
console.log("Loading all tasks..");
}
}
console.log(typeof Task); // function
let task = new Task(); // "task instantiated!"
task.showId(); // 23
Task.loadAll(); // "Loading all tasks.."
繼承用 extends,子類別的 constructor 中必須先呼叫 super();呼叫父類別方法則用 super.parentMethodName()。
class Car {
constructor() {
console.log("Creating a new car");
}
}
class Porsche extends Car {
constructor() {
super();
console.log("Creating Porsche");
}
}
let c = new Porsche();
// Creating a new car
// Creating Porsche
另外兩點值得注意:類別宣告同樣不會提升,必須先定義再使用,否則會拋出 ReferenceError;類別內定義方法不需要 function 關鍵字。
Symbol 是全新的原始型別,值唯一且不可變,主要用途是產生不會互相衝突的識別碼:
var sym = Symbol("some optional description");
console.log(typeof sym); // symbol
注意 Symbol 前面不能加 new。若它被當作物件鍵,該屬性預設不會出現在列舉結果中:
var o = {
val: 10,
[Symbol("random")]: "I'm a symbol"
};
console.log(Object.getOwnPropertyNames(o)); // ['val']
要取得 Symbol 鍵,得改用 Object.getOwnPropertySymbols(o)。
迭代器讓資料集合能被逐個存取, pointer 走到尾端時即結束。核心介面是 next(),它回傳一個帶有 done 與 value 的物件。
透過 Symbol.iterator 可以為物件掛上預設迭代器;任何時候需要遍歷該物件,執行它的 @@iterator 方法就能取得迭代器。陣列天生就是迭代器:
var arr = [11, 12, 13];
var itr = arr[Symbol.iterator]();
itr.next(); // { value: 11, done: false }
itr.next(); // { value: 12, done: false }
itr.next(); // { value: 13, done: false }
itr.next(); // { value: undefined, done: true }
實作 [Symbol.iterator]() 就能自訂物件的迭代行為。
Generator 可以讓一個函式「暫停並繼續」,逐步產出多個值。語法上是 * 加上 yield:
function* infiniteNumbers() {
var n = 1;
while (true) {
yield n++;
}
}
var numbers = infiniteNumbers(); // 回傳一個可迭代物件
numbers.next(); // { value: 1, done: false }
numbers.next(); // { value: 2, done: false }
numbers.next(); // { value: 3, done: false }
每次執行到 yield,產生的值就成為迭代結果的下一個值,函式狀態則被保留下來。
ES6 把 Promise 收進語言標準。Promise 代表一個等待完成的非同步任務,結束後狀態會變成 resolved 或 rejected。
var p = new Promise(function (resolve, reject) {
if (/* condition */) {
resolve(/* value */); // 成功
} else {
reject(/* reason */); // 失敗
}
});
每個 Promise 都有 then 方法,第一個參數處理 resolve,第二個處理 reject:
p.then(
(val) => console.log("Promise Resolved", val),
(err) => console.log("Promise Rejected", err)
);
以上就是 ES6 最常被用到的 17 項特性。把這些語法練熟,基本上就足以應付現代前端專案的日常閱讀與撰寫。