ES6(ECMAScript 2015,早期代號 harmony)是 JavaScript 語言標準在 ES5 之後最重要的一次更新,箭頭函數、類、模塊、Promise 等如今已成為日常必備的特性。下面按主題快速梳理一遍。
寫法源自 C#/Java 的 Lambda 表達式,左側是參數,右側是表達式與返回值:
var array = [1, 2, 3];
array.forEach(function (v) { console.log(v); }); // 傳統寫法
array.forEach(v => console.log(v)); // ES6 寫法
JavaScript 裡回調遍地都是,箭頭函數省下了大量 function 關鍵字。此外它還有一個重要特性:不綁定自己的 this,外層的 this 會直接沿用,這在 setTimeout、事件註冊等場景下省掉了大量 var that = this 的無奈寫法。
ES6 引入了 class 關鍵字(它其實一直是保留字)。JavaScript 本身就是面向對象的,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');
var wayou = new Programmer('wayou');
animal.sayName(); // My name is dummy
wayou.sayName(); // My name is wayou
wayou.program(); // I'm coding...
對象字面量的能力被大幅擴充:可以在字面量中直接設置原型、方法定義不必寫 function、還能直接調用父類方法。
var human {
breathe() { console.log('breathing...'); }
};
var worker = {
__proto__: human, // 設置原型,相當於繼承 human
company: 'freelancer',
work() { console.log('working...'); }
};
human.breathe(); // breathing...
worker.breathe(); // breathing...(繼承而來)
var num = Math.random();
console.log(`your num is ${num}`);
用反引號創建,${} 內可放任意表達式,同時天然支持多行。
自動把數組或對象中的值解析到對應變量。過去函數要返回多個值只能包裝成對象,現在直接返回數組即可:
function getVal() { return [1, 2]; }
var [x, y] = getVal();
console.log('x:' + x + ', y:' + y); // x:1, y:2
[name, , age] = ['wayou', 'male', 'secrect']; // 中間可跳過
console.log('name:' + name + ', age:' + age); // name:wayou, age:secrect
// 默認參數
function sayHello(name = 'dude') { console.log(`Hello ${name}`); }
sayHello(); // Hello dude
sayHello('Wayou'); // Hello Wayou
// 不定參數:收集任意個實參
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
// 拓展參數:把數組展開為多個實參
var people = ['Wayou', 'John', 'Sherlock'];
function greet(p1, p2, p3) { console.log(`Hello ${p1}, ${p2}, ${p3}`); }
greet(...people); // Hello Wayou, John, Sherlock
greet.apply(null, people); // 舊寫法,效果相同
let 聲明的變量具有塊級作用域,只在當前 {} 內有效;const 用於聲明常量。
for (let i = 0; i < 2; i++) { console.log(i); } // 0, 1
console.log(i); // undefined(嚴格模式下報錯)
塊級作用域直接解決了 for 循環閉包經典陷阱:改用 let 後,setInterval 裡的 i 不再共享同一個綁定。
var someArray = ["a", "b", "c"];
for (v of someArray) { console.log(v); } // a, b, c
與 for-in 不同,它每次給出的是值而不是索引。
JavaScript 終於原生支持 module。這種把代碼拆分成功能小塊的思路,此前是靠 CommonJS 與 AMD 等第三方規範實現的:
// point.js
module "point" {
export class Point {
constructor(x, y) { this.x = x; this.y = y; }
}
}
// myapp.js
module point from "/point.js";
import Point from "point";
var origin = new Point(0, 0);
console.log(origin);
新增的集合類型提供了 get/set 這樣的專用方法,不必再靠 hasOwnProperty 判斷屬性來自對象自身還是原型鏈:
var s = new Set();
s.add("hello").add("goodbye");
s.size === 2;
s.has("hello") === true;
var m = new Map();
m.set("hello", 42);
m.set(s, 34);
m.get(s) == 34;
var wm = new WeakMap();
wm.set(s, { extra: 42 });
var ws = new WeakSet();
ws.add({ data: 42 });
普通集合會阻止垃圾回收器釋放作為鍵的對象,容易造成內存洩露;WeakMap 與 WeakSet 的鍵是弱引用,如果外部沒有其它變量引用它們,就會被正常回收。代碼中最後一次 ws.add 傳入的是臨時對象,添加完就沒有任何引用了,因此實際上並不會保留下來。
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 () {
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
Number.EPSILON
Number.isInteger(Infinity) // false
Number.isNaN("NaN") // false
// Math
Math.acosh(3) // 1.762747174039086
Math.hypot(3, 4) // 5
Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2
// String
"abcde".contains("cd") // true
"abc".repeat(3) // "abcabcabc"
// Array
Array.from(document.querySelectorAll('*')) // 類數組轉真數組
Array.of(1, 2, 3)
[0, 0, 0].fill(7, 1) // [0, 7, 7]
[1, 2, 3].findIndex(x => x == 2) // 1
["a", "b", "c"].entries() // 索引鍵值對迭代器
["a", "b", "c"].keys() // 索引迭代器
["a", "b", "c"].values() // 值迭代器
// Object
Object.assign(Point, { origin: new Point(0, 0) })
Promise 是處理異步的標準模式,此前 jQuery 的 deferred 對象就是類似思路。顯著的優勢在於錯誤可以被統一捕獲,也不會陷入回調地獄:
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"
});
ES6 的改動幾乎覆蓋了語言的每個角落。對日常開發影響最大的莫過於 let/const、箭頭函數、模板字符串、解構、Promise 和模塊化——它們直接改變了我們寫代碼的手感。etter 的做法是挑一兩個項目,人為地只用新語法重寫一遍,適應速度會比單純看文章快得多。