ECMAScript 6 は現在ほぼ業界標準となっており、その普及速度は ES5 よりはるかに速いです。主な理由は、モダンブラウザーの ES6 対応が非常に早く、特に Chrome と Firefox は ES6 のほとんどの機能をすでにサポートしているからです。


1. let、const とブロックスコープ

let はブロックスコープを作成できます。ES6 では関数内で変数を定義する際、var ではなく let を使用することが推奨されています:

var a = 2;
{
  let a = 3;
  console.log(a); // 3
}
console.log(a); // 2

同様にブロックスコープで有効なもう一つの変数宣言方法は const です。const は定数を宣言できます。ES6 では、const で宣言された定数はポインタに似ており、何らかの参照を指します。つまりこの「定数」は不変というわけではありません。例えば:

{
  const ARR = [5,6];
  ARR.push(7);
  console.log(ARR); // [5,6,7]
  ARR = 10; // TypeError
}

いくつか注意すべき点があります:

  • let キーワードで宣言された変数は変数の巻き上げ(hoisting)特性を持ちません。
  • let と const の宣言は最も近いブロック(中括弧内)でのみ有効です。
  • const 定数を宣言する場合は、大文字の変数を使用してください。例:CAPITAL_CASING
  • const は宣言時に代入されなければなりません。

2. アロー関数(Arrow Functions)

ES6 では、アロー関数は関数の簡略表記の一種です。引数を括弧で囲み、=> を続け、その直後に関数本体がきます。

var getPrice = function() {
  return 4.55;
};
 
// Implementation with Arrow Function
var getPrice = () => 4.55;

注意すべき点は、上記の例の getPrice アロー関数は簡潔な関数本体を採用しており、return 文が不要です。次の例では通常の関数本体を使用しています:

let arr = ['apple', 'banana', 'orange'];
 
let breakfast = arr.map(fruit => {
  return fruit + 's';
});
 
console.log(breakfast); // apples bananas oranges

もちろん、アロー関数はコードを簡潔にするだけではありません。関数内の this は常にオブジェクト自身を指すようにバインドされます。具体的には次の例を見てください:

function Person() {
  this.age = 0;
 
  setInterval(function growUp() {
    // 在非严格模式下,growUp() 函数的 this 指向 window 对象
    this.age++;
  }, 1000);
}
var person = new Person();

従来は this を変数に保存し、その後 growUp 関数内で参照する必要がありました:

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. 関数パラメータのデフォルト値

ES6 では関数パラメータにデフォルト値を設定できます:

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

4. Spread / Rest オペレーター

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. オブジェクト構文の拡張

ES6 では、オブジェクトリテラルを宣言する際に省略構文を使用して、プロパティ変数の初期化や関数の定義を行うことができます。また、オブジェクトプロパティ内で計算操作を行うこともできます:

function getCar(make, model, value) {
  return {
    // 简写变量
    make,  // 等同于 make: make
    model, // 等同于 model: model
    value, // 等同于 value: value
 
    // 属性可以使用表达式计算值
    ['make' + make]: true,
 
    // 忽略 `function` 关键词简写对象函数
    depreciate() {
      this.value -= 2500;
    }
  };
}
 
let car = getCar('Barret', 'Lee', 40000);
 
// output: {
//     make: 'Barret',
//     model:'Lee',
//     value: 40000,
//     makeBarret: true,
//     depreciate: [Function: depreciate]
// }

6. 2進数と8進数のリテラル

ES6 は2進数と8進数のリテラルをサポートしています。数値の前に 0o または 0O を付けると8進数に変換できます:

let oValue = 0o10;
console.log(oValue); // 8
 
let bValue = 0b10; // 二进制使用 `0b` 或者 `0B`
console.log(bValue); // 2

7. オブジェクトと配列の分割代入

分割代入は、オブジェクトへの代入時に中間変数を生成することを回避できます:

function foo() {
  return [1,2,3];
}
let arr = foo(); // [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: x, y: y, z: z} = bar();
console.log(x, y, z); // 4 5 6

8. オブジェクトのスーパークラス

ES6 ではオブジェクト内で 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. テンプレート構文と区切り文字

ES6 には、文字列と変数を組み立てる非常に簡潔な方法があります。

  • ${ ... } は変数を描画するために使用します。
  • ` は区切り文字として使用します。
let user = 'Barret';
console.log(`Hi ${user}!`); // Hi Barret!

10. for...of VS 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);
}
Result: 0, 1, 2, size

11. Map と WeakMap

ES6 には2つの新しいデータ構造コレクション、Map と WeakMap があります。実際、すべてのオブジェクトは Map と見なすことができます。

オブジェクトは複数の key-val ペアで構成されます。Map では、あらゆる型をオブジェクトのキーとして使用できます。例:

var myMap = new Map();
 
var keyString = "a string",
    keyObj = {},
    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 は Map と同様ですが、そのすべてのキーが弱参照です。つまり WeakMap 内のものはガベージコレクションの対象として考慮されないため、メモリリークを心配する必要がありません。

もう一つ注意すべき点は、WeakMap のすべてのキーはオブジェクトでなければならないことです。WeakMap には delete(key), has(key), get(key), set(key, val) の4つのメソッドしかありません:

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, because that is the set value
 
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 });

Set オブジェクトは 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);
    // 1
    // 2
    // 3
    // 'strings'
    // Object { a: 1, b: 2 }
}

Set にも同様に delete() と clear() メソッドがあります。

WeakSet

WeakMap と同様に、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); // 从结合中删除 window 对象
ws.has(window);    // false, window 对象已经被删除

13. クラス

ES6 には class 構文があります。注目すべきは、ここでの 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.."

クラスにおける継承とスーパークラス:

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

extends はサブクラスが親クラスを継承することを可能にします。注意すべき点は、サブクラスの constructor 関数内で super() 関数を実行する必要があることです。

もちろん、サブクラスのメソッド内で親クラスのメソッドを呼び出すこともできます。例:super.parentMethodName()

ここ でクラスについての詳細を読んでください。

注目すべき点がいくつかあります:

  • クラス宣言は巻き上げ(hoisting)されません。もし特定のクラスを使用する場合は、使用する前に定義する必要があります。そうしないと ReferenceError エラーがスローされます。
  • クラス内で関数を定義する際に function キーワードは不要です。

14. Symbol

Symbol は新しいデータ型で、その値は一意かつ不変です。ES6 で 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)

イテレーターは、データコレクションの要素に一度に1つずつアクセスできます。ポインターがデータコレクションの最後の要素を指すと、イテレーターは終了します。シーケンスを走査するための next() 関数が用意されており、このメソッドは done と value プロパティを含むオブジェクトを返します。

ES6 では、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. Generators

Generator 関数は ES6 の新機能で、関数が返す反復可能なオブジェクトが複数の値を生成できるようにします。

使用中に * 構文と新しいキーワード yield を目にすることになります:

function *infiniteNumbers() {
  var n = 1;
  while (true){
    yield n++;
  }
}
 
var numbers = infiniteNumbers(); // returns an iterable object
 
numbers.next(); // { value: 1, done: false }
numbers.next(); // { value: 2, done: false }
numbers.next(); // { value: 3, done: false }

yield を実行するたびに、返された値がイテレーターの次の値になります。

17. Promises

ES6 は Promise をネイティブにサポートしています。Promise は非同期実行を待つオブジェクトであり、実行が完了すると、その状態は resolved または rejected になります。

var p = new Promise(function(resolve, reject) {  
  if (/* condition */) {
    // fulfilled successfully
    resolve(/* value */);  
  } else {
    // error, rejected
    reject(/* reason */);  
  }
});

すべての Promise には .then メソッドがあります。このメソッドは2つの引数を受け取ります。1つ目は resolved 状態を処理するコールバック、もう1つは rejected 状態を処理するコールバックです:

p.then((val) => console.log("Promise Resolved", val),
       (err) => console.log("Promise Rejected", err));

原文:https://github.com/metagrover/ES6-for-humans

訳文:http://www.barretlee.com/blog/2016/07/09/a-kickstarter-guide-to-writing-es6/

訳/小胡子哥