DIV CSS 佈局教程網

ES6 新特性巡禮:箭頭函數、class、解構與 Promise
編輯:關於JavaScript     

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)的支援

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}`);

解構(Destructuring)

自動解析陣列或物件中的值。過去函數要回傳多個值時,得包成物件再逐一取出;現在可以直接回傳陣列,讓值自動對應到變量上。

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 與 const

可以把 let 理解為「有區塊作用域的 var」;const 則用來宣告不可重新指派的常數。

for (let i = 0; i < 2; i++) console.log(i); // 0, 1
console.log(i); // undefined(嚴格模式下會報錯)

for...of 值遍歷

for-in 提供的是索引,ES6 新增的 for-of 提供的則是值本身。

var someArray = ["a", "b", "c"];
for (v of someArray) {
  console.log(v); // a, b, c
}

Iterator 與 Generator

這部分概念稍抽象,先記住幾個名詞:

  • iterator:擁有 next 方法的物件,該方法回傳 {done, value},done 為布林值、value 為任意值。
  • iterable:擁有 obj[@@iterator] 方法的物件,該方法回傳一個 iterator。
  • generator:一種特殊的 iterator,其 next 可接收參數,回傳值取決於它的建構函數,另外還有一個 throw 方法。
  • generator 函數:即 generator 的建構函數,以 function* 宣告,內部可使用 yield。
  • yield:暫停函數執行,之後可再從該處繼續。

模組(Module)

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

Map、Set、WeakMap、WeakSet

這幾種新的集合型別提供了更方便的存取方式,不必再靠 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

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() 函數產生,接收一個可選的名稱參數,回傳值保證唯一。除了當鍵使用,它也常被拿來建立私有屬性——外部無法直接存取以 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; // 無法存取,因為它是私有的

Math、Number、String、Object 的新 API

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

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"
});

把這些特性放在一起看,會發現一個明顯趨勢:前後端的語法差異正在快速縮小。熟悉這些新語法,不只是為了寫得更短,而是能用更貼近問題本質的方式來表達意圖。

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