DIV CSS 佈局教程網

ES6 快速上手:17 個必學新特性一次掌握
編輯:JavaScript基礎知識     

ECMAScript 6(後來的正式名稱是 ECMAScript 2015)是 JavaScript 語言發展史上幅度最大的一次升級。它的目標很明確:讓 JavaScript 有能力承載大型應用、通用函式庫,甚至成為產生程式碼的程式碼生成器(code generator)。

好消息是,ES6 早已不是紙上規格。主流瀏覽器對它的支援推進得比當年 ES5 快得多,Chrome 與 Firefox 幾乎實作了絕大部分語法特性,日常開發已經可以大方使用。以下整理 17 個最關鍵的新語法,作為快速入門的路線圖。

1. let、const 與區塊作用域

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 在宣告的同時就必須完成賦值。

2. 箭頭函式(Arrow Functions)

箭頭函式是函式的簡寫形式:一對括號包住參數,接著是 =>,後面是函式主體。

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();

3. 函式參數預設值

參數預設值讓函式簽名更能自我說明:

let getFinalPrice = (price, tax = 0.7) => price + price * tax;
getFinalPrice(500); // 850

4. Spread / Rest 運算子

... 到底是 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]

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

6. 二進位與八進位字面值

數字前加上 0o 表示八進位,加上 0b 表示二進位:

let oValue = 0o10;
console.log(oValue); // 8

let bValue = 0b10;
console.log(bValue); // 2

7. 解構賦值

解構可以省掉一堆中間變數:

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

8. 物件中的 super

物件也可以透過 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

9. 模板字面值

用反引號當分隔符,${ } 裡面放運算式,字串拼接終於變得可讀:

let user = 'Barret';
console.log(`Hi ${user}!`); // Hi Barret!

10. for...of 與 for...in 的差別

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

11. Map 與 WeakMap

某種意義上,每個物件都是一個 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

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

12. Set 與 WeakSet

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

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 已被刪除

13. class 類別語法

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 關鍵字。

14. Symbol

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)。

15. 迭代器(Iterators)

迭代器讓資料集合能被逐個存取, 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]() 就能自訂物件的迭代行為。

16. Generator 函式

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,產生的值就成為迭代結果的下一個值,函式狀態則被保留下來。

17. Promise

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 項特性。把這些語法練熟,基本上就足以應付現代前端專案的日常閱讀與撰寫。

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