
ECMAScript 2015(ES6)問世後,語法糖的加持讓許多原本繁瑣的操作變得直觀。本文不逐條講解理論,而是用大量可直接執行的範例,快速建立對這套新規範的整體認識。
function() 的簡寫形式,但它不綁定自己的 this。
var odds = evens.map(v => v + 1); // 省略括號與大括號
var nums = evens.map((v, i) => v + i);
var pairs = evens.map(v => ({even: v, odd: v + 1}));
// 帶語句區塊的寫法
nums.forEach(v => {
if (v % 5 === 0) fives.push(v);
});
this 的行為差異:
var object = {
name: "Name",
arrowGetName: () => this.name,
regularGetName: function() { return this.name },
arrowGetThis: () => this,
regularGetThis: function() { return this }
}
console.log(this.name);
console.log(object.arrowGetName());
console.log(object.arrowGetThis());
console.log(this);
console.log(object.regularGetName());
console.log(object.regularGetThis());
結果:箭頭函數取到的是外層(全域/window)的 this,一般函式取到的才是 object 本身。
ES6 的 class 本質上是原型繼承的語法糖。
class SkinnedMesh extends THREE.Mesh {
constructor(geometry, materials) {
super(geometry, materials);
this.idMatrix = SkinnedMesh.defaultMatrix();
this.bones = [];
this.boneMatrices = [];
// ...
}
update(camera) {
// ...
super.update();
}
get boneCount() { return this.bones.length; }
set matrixType(matrixType) { this.idMatrix = SkinnedMesh[matrixType](); }
static defaultMatrix() { return new THREE.Matrix4(); }
}
var theProtoObj = {
toString: function() { return "The ProtoOBject To string" }
}
var handler = () => "handler"
var obj = {
__proto__: theProtoObj,
handler, // handler: handler 的縮寫
toString() { // 方法定義
return "d " + super.toString();
},
[ "prop_" + (() => 42)() ]: 42 // 計算屬性名
};
console.log(obj.handler); // () => "handler"
console.log(obj.handler()); // handler
console.log(obj.toString()); // d The ProtoOBject To string
console.log(obj.prop_42); // 42
var name = "Bob", time = "today";
var multiLine = `This Line Spans Multiple Lines`
console.log(`Hello ${name}, how are you ${time}?`);
// Hello Bob, how are you today?
console.log(multiLine);
陣列的列表匹配:
var [a, , b] = [1, 2, 3]; console.log(a); // 1 console.log(b); // 3
物件的解構:
nodes = () => { return {op: "a", lhs: "b", rhs: "c"} }
var { op: a, lhs: b, rhs: c } = nodes();
console.log(a, b, c); // a b c
速記寫法(變數名與屬性名相同):
nodes = () => { return {lhs: "a", op: "b", rhs: "c"} }
var {op, lhs, rhs} = nodes();
console.log(op, lhs, rhs); // b a c
用在參數位置:
function g({name: x}) { return x }
function m({name}) { return name }
console.log(g({name: 5})); // 5
console.log(m({name: 5})); // 5
var [a] = [] var [b = 1] = [] var c = []; console.log(a); // undefined console.log(b); // 1 console.log(c); // []
function f(x, y = 12) { return x + y; }
console.log(f(3)); // 15
console.log(f(3, 2)); // 5
function f(x, y, z) { return x + y + z; }
console.log(f(...[1, 2, 3])); // 6
var parts = ["shoulders", "knees"];
var lyrics = ["head", ...parts, "and", "toes"];
// ["head","shoulders","knees","and","toes"]
搭配物件字面量:
let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
console.log(x); // 1
console.log(y); // 2
console.log(z); // { a: 3, b: 4 }
let n = { x, y, ...z };
console.log(n); // { x: 1, y: 2, a: 3, b: 4 }
物件展開在當時仍需外掛支援:npm install --save-dev babel-plugin-transform-object-rest-spread
function demo(part1, ...part2) { return {part1, part2} }
console.log(demo(1, 2, 3, 4, 5, 6));
// {"part1":1,"part2":[2,3,4,5,6]}
let 具備塊級作用域,可視為新的 var。
{ var globalVar = "from demo1" }
{ let globalLet = "from demo2"; }
console.log(globalVar); // from demo1
console.log(globalLet); // ReferenceError: globalLet is not defined
但它不會掛到 window 上:
let me = "go"; var i = "able"; console.log(window.me); // undefined console.log(window.i); // able
且不能重複宣告:
let me = "foo"; let me = "bar"; // SyntaxError: Identifier 'me' has already been declared var me = "foo"; var me = "bar"; console.log(me); // bar
const 宣告的是唯讀綁定。
const a = "b"; a = "a"; // TypeError: Assignment to constant variable.
但物件的內容仍可變動:
const a = { a: "a" };
a.a = "b";
console.log(a); // {"a":"b"}
新的迭代語法,回傳的是值而非鍵名。
let list = [4, 5, 6];
for (let i in list) { console.log(i); } // 0 1 2
for (let i of list) { console.log(i); } // 4 5 6
let infinite = {
[Symbol.iterator]() {
let c = 0;
return { next() { c++; return { done: false, value: c } } }
}
}
console.log("start");
for (var n of infinite) {
if (n > 10) break;
console.log(n);
}
用 TypeScript 看介面定義:
interface IteratorResult { done: boolean; value: any; }
interface Iterator { next(): IteratorResult; }
interface Iterable { [Symbol.iterator](): Iterator }
var infinity = {
[Symbol.iterator]: function*() {
var c = 1;
for (;;) { yield c++; }
}
}
for (var n of infinity) {
if (n > 10) break;
console.log(n);
}
interface Generator extends Iterator {
next(value?: any): IteratorResult;
throw(exception: any);
}
透過 yield* 委派給另一個生成器:
function* anotherGenerator(i) {
yield i + 1;
yield i + 2;
yield i + 3;
}
function* generator(i) {
yield i;
yield* anotherGenerator(i);
yield i + 10;
}
var gen = generator(10);
console.log(gen.next().value); // 10
console.log(gen.next().value); // 11
console.log(gen.next().value); // 12
console.log(gen.next().value); // 13
console.log(gen.next().value); // 20
var regex = new RegExp('\u{61}', 'u');
console.log(regex.unicode); // true
console.log("\uD842\uDFD7"); // 對應的罕用字
console.log("\uD842\uDFD7".codePointAt());
import defaultMember from "module-name";
import * as name from "module-name";
import { member } from "module-name";
import { member as alias } from "module-name";
import { member1, member2 } from "module-name";
import { member1, member2 as alias2, [...] } from "module-name";
import defaultMember, { member [, [...]] } from "module-name";
import defaultMember, * as name from "module-name";
import "module-name";
export { name1, name2, ..., nameN };
export { variable1 as name1, variable2 as name2, ..., nameN };
export let name1, name2, ..., nameN;
export let name1 = ..., name2 = ..., ..., nameN;
export expression;
export default expression;
export default function (...) { ... }
export default function name1(...) { ... }
export { name1 as default, ... };
export * from ...;
export { name1, name2, ..., nameN } from ...;
export { import1 as name1, import2 as name2, ..., nameN } from ...;
類比於數學上的集合,元素唯一,等同 SQL 的 distinct。
var set = new Set();
set.add("Potato").add("Tomato").add("Tomato");
console.log(set.size); // 2
console.log(set.has("Tomato")); // true
for (var item of set) { console.log(item); } // Potato, Tomato
只能存放物件,且對元素保持弱引用,沒有其他引用時會被回收。
var item = { a: "Potato" }
var set = new WeakSet();
set.add({ a: "Potato" }).add(item).add({ a: "Tomato" }).add({ a: "Tomato" });
console.log(set.size); // undefined
console.log(set.has({a:"Tomato"})); // false
console.log(set.has(item)); // true
// for (let item of set) ... // TypeError: 不可迭代
也稱字典,鍵可以是任意型別。
var map = new Map();
map.set("Potato", 12);
map.set("Tomato", 34);
console.log(map.get("Potato")); // 12
for (let item of map) { console.log(item); }
// ["Potato",12] / ["Tomato",34]
var map = new Map();
var key = {a: "a"};
map.set(key, 12);
console.log(map.get(key)); // 12
console.log(map.get({a: "a"})); // undefined,因為是不同物件
以物件為鍵,且只對鍵保持弱引用。
var wm = new WeakMap();
var o1 = {}, o2 = {}, o3 = {};
wm.set(o1, 1);
wm.set(o2, 2);
wm.set(o3, {a: "a"});
wm.set({}, 4);
console.log(wm.get(o2)); // 2
console.log(wm.has({})); // false
console.log(wm.get(o3)); // {"a":"a"}
// 不可迭代
用來攔截並改變物件的行為,透過 trap 自訂各類操作。
var obj = function ProfanityGenerator() {
return { words: "Horrible words" }
}()
var handler = function CensoringHandler() {
return {
get: function (target, key) {
return target[key].replace("Horrible", "Nice");
}
}
}()
var proxy = new Proxy(obj, handler);
console.log(proxy.words); // Nice words
可用的 trap 包含:
var handler = {
get: ..., set: ..., has: ..., deleteProperty: ..., apply: ...,
construct: ..., getOwnPropertyDescriptor: ..., defineProperty: ...,
getPrototypeOf: ..., setPrototypeOf: ..., enumerate: ...,
ownKeys: ..., preventExtensions: ..., isExtensible: ...
}
新增的原始型別,常用於建立不會對外碰撞的屬性。
var typeSymbol = Symbol("type");
class Pet {
constructor(type) { this[typeSymbol] = type; }
getType() { return this[typeSymbol]; }
}
var a = new Pet("dog");
console.log(a.getType()); // dog
console.log(Object.getOwnPropertyNames(a)); // []
console.log(Symbol("a") === Symbol("a")); // false
class CustomArray extends Array { }
var a = new CustomArray();
a[0] = 2;
console.log(a[0]); // 2
console.log(Number.EPSILON); // 2.220446049250313e-16
console.log(Number.isInteger(Infinity)); // false
console.log(Number.isNaN("NaN")); // false
console.log(Math.acosh(3)); // 1.7627471740390859
console.log(Math.hypot(3, 4)); // 5
console.log("abcde".includes("cd")); // true
console.log("abc".repeat(3)); // abcabcabc
console.log(Array.of(1, 2, 3)); // [1,2,3]
console.log([0, 0, 0].fill(7, 1)); // [0,7,7]
console.log([1, 2, 3].find(x => x == 3)); // 3
console.log([1, 2, 3].findIndex(x => x == 2)); // 1
console.log([1, 2, 3, 4, 5].copyWithin(3, 0)); // [1,2,3,1,2]
console.log(Object.assign({}, { origin: "point" }));
console.log(0b11111); // 31 console.log(0o2342); // 1250 console.log(0xff); // 255,ES5 即支援
var p1 = new Promise((resolve, reject) => {
setTimeout(() => resolve("1"), 101)
})
var p2 = new Promise((resolve, reject) => {
setTimeout(() => resolve("2"), 100)
})
Promise.race([p1, p2]).then(res => console.log(res)); // 2
Promise.all([p1, p2]).then(res => console.log(res)); // ["1","2"]
快速建立已定案的 Promise:
var p1 = Promise.resolve("1");
var p2 = Promise.reject("2");
Promise.race([p1, p2]).then(res => console.log(res)); // 1
快速失敗:只要有一個 reject,all 與 race 都會進入失敗分支。
var p1 = new Promise((resolve, reject) => {
setTimeout(() => resolve("1"), 1001)
})
var p2 = new Promise((resolve, reject) => {
setTimeout(() => reject("2"), 1)
})
Promise.race([p1, p2]).then(
res => console.log("success " + res),
res => console.log("error " + res) // error 2
);
Promise.all([p1, p2]).then(
res => console.log("success " + res),
res => console.log("error " + res) // error 2
);
var z = {w: "Super Hello"};
var y = {x: "hello", __proto__: z};
console.log(Reflect.getOwnPropertyDescriptor(y, "x"));
// {"value":"hello","writable":true,"enumerable":true,"configurable":true}
console.log(Reflect.has(y, "w")); // true
console.log(Reflect.ownKeys(y)); // ["x"]
console.log(Reflect.deleteProperty(y, "x")); // true
console.log(Reflect.has(y, "x")); // false
所謂尾端呼叫,指函式的最後一步就是呼叫另一個函式。ES6 規格允許引擎重用堆疊框架,避免這類遞迴造成堆疊溢出(實際支援度依引擎而異)。
function factorial(n, acc = 1) {
if (n <= 1) return acc;
return factorial(n - 1, n * acc);
}
console.log(factorial(10)); // 3628800
console.log(factorial(100)); // 9.332621544394418e+157
console.log(factorial(1000)); // Infinity
// 未支援尾端呼叫最佳化的引擎會在更大輸入時丟出
// RangeError: Maximum call stack size exceeded
以上就是 ES6 主要新特性的範例速覽,搭配 MDN 或 caniuse 查詢支援度,就能在專案中安心採用。