ES6 的文件中,不少語法設計借鑑自 C#、Java 等語言,寫起來確實比舊版 JavaScript 清爽許多。下面依主題快速看過幾項最具代表性的新特性,每個都附上可直接對照的程式碼。
寫過 C# 或 Java 的人對 lambda 表達式不陌生,ES6 的箭頭操作符 => 頗有異曲同工之妙:左邊是輸入參數,右邊是操作與回傳值(Inputs => outputs)。
JavaScript 裡回調俯拾即是,而回調又常以匿名函數形式出現,每次都得寫一個 function 相當累贅。有了箭頭函數之後:
var array = [1, 2, 3];
// 傳統寫法
array.forEach(function (v, i, a) {
console.log(v);
});
// ES6
array.forEach(v => console.log(v));
class 一直是 JavaScript 的保留字,如今終於派上用場。要說清楚的是:JS 本身就是物件導向語言,ES6 提供的 class 只是原型模式的語法糖。不過有了原生支援之後,物件的建立、繼承、父類方法呼叫、實例化、靜態方法與建構函數等概念都變得直觀得多。
// 類的定義
class Animal {
// 建構器
constructor(name) {
this.name = name;
}
// 實例方法
sayName() {
console.log('My name is ' + this.name);
}
}
// 類的繼承
class Programmer extends Animal {
constructor(name) {
super(name); // 呼叫父類建構器
}
program() {
console.log("I'm coding...");
}
}
// 測試
var animal = new Animal('dummy'),
wayou = new Programmer('wayou');
animal.sayName(); // My name is dummy
wayou.sayName(); // My name is wayou
wayou.program(); // I'm coding...
字面量的功能變得更完整,主要體現在三點:可以在字面量裡定義原型、定義方法時不必寫 function、可以直接呼叫父類方法。這些都讓它與 class 的概念更為一致。
// 透過字面量建立物件
var human = {
breathe() {
console.log('breathing...');
}
};
var worker = {
__proto__: human, // 設定原型為 human,等同繼承
company: 'freelancer',
work() {
console.log('working...');
}
};
human.breathe(); // breathing...
worker.breathe(); // breathing...(呼叫繼承而來的方法)
ES6 允許用反引號建立字串,字串中可包含以 ${ } 包裹的變量。用過 C# 等強型別語言的人對此應該不陌生。
var num = Math.random();
console.log(`your num is ${num}`);
自動解析陣列或物件中的值。過去函數要回傳多個值時,得包成物件再逐一取出;現在可以直接回傳陣列,讓值自動對應到變量上。
var [x, y] = getVal(), // 函數回傳值的解構
[name, , age] = ['wayou', 'male', 'secret']; // 陣列解構,中間留空可跳過
function getVal() {
return [1, 2];
}
console.log('x:' + x + ', y:' + y); // x:1, y:2
console.log('name:' + name + ', age:' + age); // name:wayou, age:secret
function sayHello(name) {
// 傳統做法
var name = name || 'dude';
console.log('Hello ' + name);
}
// ES6 寫法
function sayHello2(name = 'dude') {
console.log(`Hello ${name}`);
}
sayHello(); // Hello dude
sayHello('Wayou'); // Hello Wayou
sayHello2(); // Hello dude
sayHello2('Wayou'); // Hello Wayou
用「...」搭配變量名,就能一次接收任意數量的參數。這只是語法糖,過去靠 arguments 也能做到。
// 把所有參數相加
function add(...x) {
return x.reduce((m, n) => m + n);
}
console.log(add(1, 2, 3)); // 6
console.log(add(1, 2, 3, 4, 5)); // 15
另一種形式的語法糖,讓陣列或類陣列可以直接當成函數參數傳入,不必再用 apply。
var people = ['Wayou', 'John', 'Sherlock'];
function sayHello(people1, people2, people3) {
console.log(`Hello ${people1},${people2},${people3}`);
}
sayHello(...people); // Hello Wayou,John,Sherlock
// 以前的做法
sayHello.apply(null, people); // Hello Wayou,John,Sherlock
可以把 let 理解為「有區塊作用域的 var」;const 則用來宣告不可重新指派的常數。
for (let i = 0; i < 2; i++) console.log(i); // 0, 1 console.log(i); // undefined(嚴格模式下會報錯)
for-in 提供的是索引,ES6 新增的 for-of 提供的則是值本身。
var someArray = ["a", "b", "c"];
for (v of someArray) {
console.log(v); // a, b, c
}
這部分概念稍抽象,先記住幾個名詞:
ES6 讓 JavaScript 原生支援 module。這種把程式碼依功能切分的想法,源自 CommonJS 與 AMD 等社群規範。各模組只對外導出公開介面,再由使用方導入:
// point.js
module "point" {
export class Point {
constructor (x, y) {
public x = x;
public y = y;
}
}
}
// myapp.js
module point from "/point.js"; // 宣告引用的模組
import Point from "point"; // 指定要導入的部分
var origin = new Point(0, 0);
console.log(origin);
這幾種新的集合型別提供了更方便的存取方式,不必再靠 hasOwnProperty 去分辨某個屬性屬於原型鏈還是當前物件,新增與取值也有專門的 get、set 方法。
// Set
var s = new Set();
s.add("hello").add("goodbye").add("hello");
s.size === 2; // true
s.has("hello") === true;
// Map
var m = new Map();
m.set("hello", 42);
m.set(s, 34);
m.get(s) == 34;
當我們把物件當成另一個物件的鍵來存放值時,普通集合會阻止垃圾回收器回收這些鍵物件,有洩漏風險。WeakMap 與 WeakSet 則安全得多:若這些鍵物件沒有其他變量參照,就會被回收。
// WeakMap
var wm = new WeakMap();
wm.set(s, { extra: 42 });
wm.size === undefined;
// WeakSet
var ws = new WeakSet();
ws.add({ data: 42 }); // 這個暫人物件沒有其他參照,因此實際上不會被保存
Proxy 可以攔截物件上發生的事情並執行對應操作,讓我們對物件具備很強的追蹤能力,在資料綁定場景特別有用。
// 被偵聽的目標物件
var engineer = {
name: 'Joe Sixpack',
salary: 50
};
// 定義處理器
var interceptor = {
set: function (receiver, property, value) {
console.log(property, 'is changed to', value);
receiver[property] = value;
}
};
// 建立代理
engineer = Proxy(engineer, interceptor);
// 觸發代理
engineer.salary = 60; // 主控台輸出:salary is changed to 60
處理器裡設定了 set 函數,代表當被偵聽物件的屬性被寫入時就會呼叫它,並透過參數得知是哪個屬性、被改成了什麼值。
物件的鍵通常是字串,現在還多了一個選項:symbol。它是像數字、字串、布林那樣的基本型別而非物件,透過 Symbol() 函數產生,接收一個可選的名稱參數,回傳值保證唯一。除了當鍵使用,它也常被拿來建立私有屬性——外部無法直接存取以 symbol 為鍵的屬性。
(function () {
// 建立 symbol
var key = Symbol("key");
function MyClass(privateData) {
this[key] = privateData;
}
MyClass.prototype = {
doStuff: function () {
// ... this[key] ...
}
};
// 若要對外提供方法,可在此處掛上
})();
var c = new MyClass("hello");
c["key"] === undefined; // 無法存取,因為它是私有的
Number.EPSILON
Number.isInteger(Infinity) // false
Number.isNaN("NaN") // false
Math.acosh(3) // 1.762747174039086
Math.hypot(3, 4) // 5
Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2
"abcde".contains("cd") // true
"abc".repeat(3) // "abcabcabc"
Array.from(document.querySelectorAll('*')) // 轉成真陣列
Array.of(1, 2, 3) // 類似 new Array(...),但沒有單參數特例
[0, 0, 0].fill(7, 1) // [0, 7, 7]
[1, 2, 3].findIndex(x => x == 2) // 1
["a", "b", "c"].entries() // iterator: [0,"a"], [1,"b"], [2,"c"]
["a", "b", "c"].keys() // iterator: 0, 1, 2
["a", "b", "c"].values() // iterator: "a", "b", "c"
Object.assign(Point, { origin: new Point(0, 0) })
Promise 是處理異步操作的標準模式,早期在許多第三方庫中已有實作,例如 jQuery 的 deferred 物件。當你發出一個異步請求並綁上 then、done 之類的處理器時,其實就是在用它。
// 建立 promise
var promise = new Promise(function (resolve, reject) {
// 進行一些異步或耗時操作
if (/* 成功 */) {
resolve("Stuff worked!");
} else {
reject(Error("It broke"));
}
});
// 綁定處理器
promise.then(function (result) {
// 成功時執行這裡
console.log(result); // "Stuff worked!"
}, function (err) {
// 失敗時執行這裡
console.log(err); // Error: "It broke"
});
把這些特性放在一起看,會發現一個明顯趨勢:前後端的語法差異正在快速縮小。熟悉這些新語法,不只是為了寫得更短,而是能用更貼近問題本質的方式來表達意圖。