1.遍歷Map結構;任何部署了Iterator接口的對象，都可以用for...of循環遍歷。Map結構原生支持Iterator接口，配合變量的結構賦值，獲取鍵名和鍵值就非常方便。

    var map = new Map();
    map.set(‘first‘, ‘hello‘);
    map.set(‘second‘, ‘world‘);
    for (let [key, value] of map) {
      console.log(key + " is " + value);
     }
     // first is hello
     // second is world

如果只想獲取鍵名，或者只想獲取鍵值，可以寫成下面這樣。

    // 獲取鍵名
    for (let [key] of map) {
      // ...
    }
    
    // 獲取鍵值
    for (let [,value] of map) {
      // ...
    }

2.輸入模塊的指定方法;加載模塊時，往往需要指定輸入那些方法。解構賦值使得輸入語句非常清晰。

const { SourceMapConsumer, SourceNode } = require("source-map");

3.字符串擴展

charCodeAt方法只能分別返回前兩個字節和後兩個字節的值。

var s = "";
s.length // 2
s.charAt(0) // ‘‘
s.charAt(1)    // ‘‘
s.charCodeAt(0) // 55362        
s.charCodeAt(1) // 57271

codePointAt方法，能夠正確處理4個字節儲存的字符;codePointAt方法會正確返回四字節的UTF-16字符的碼點。對於那些兩個字節儲存的常規字符，它的返回結果與charCodeAt方法相同。

    var s = "a";
    s.codePointAt(0) // 134071
    s.codePointAt(1) // 57271
    s.charCodeAt(2) // 97

ES6提供了String.fromCodePoint方法，可以識別0xFFFF的字符，彌補了String.fromCharCode方法的不足。在作用上，正好與codePointAt方法相反。

    String.fromCodePoint(0x20BB7)
     // ""

ES7提供了at方法，可以識別Unicode編號大於0xFFFF的字符，返回正確的字符。

    ‘‘.at(0)
    // ‘‘

字符的Unicode表示法:

ES6對這一點做出了改進，只要將碼點放入大括號，就能正確解讀該字符。

    "\u{20BB7}"
    // ""
    
    "\u{41}\u{42}\u{43}"
    // "ABC"

Unicode字符表示法:

ES6新增了使用大括號表示Unicode字符，這種表示法在正則表達式中必須加上u修飾符，才能識別。

    /\u{61}/.test(‘a‘) // false
    /\u{61}/u.test(‘a‘) // true
    /\u{20BB7}/u.test(‘‘) // true

上面代碼表示，如果不加u修飾符，正則表達式無法識別\u{61}這種表示法，只會認為這匹配61個連續的u。

量詞

使用u修飾符後，所有量詞都會正確識別大於碼點大於0xFFFF的Unicode字符。

    /a{2}/.test(‘aa‘) // true
    /a{2}/u.test(‘aa‘) // true
    /{2}/.test(‘‘) // false
    /{2}/u.test(‘‘) // true

ES6 Class

//定義類
class Point {

  constructor(x, y) {
    this.x = x;
    this.y = y;
  }

  toString() {
    return ‘(‘+this.x+‘, ‘+this.y+‘)‘;
  }
}

var point = new Point(2,3);

point.toString() // (2, 3)

constructor函數是構造函數
this關鍵字則代表實例對象
定義了一個toString方法

Class之間可以通過extends關鍵字，實現繼承。

class ColorPoint extends Point {}

上面代碼定義了一個ColorPoint類，該類通過extends關鍵字，繼承了Point類的所有屬性和方法。

class ColorPoint extends Point {

  constructor(x, y, color) {
    super(x, y); // 等同於super.constructor(x, y)    
    this.color = color;
  }

  toString() {
    return this.color+‘ ‘+super();
  }
}

上面代碼中，constructor方法和toString方法之中，都出現了super關鍵字，它指代父類的同名方法。在constructor方法內，super指代父類的constructor方法；在toString方法內，super指代父類的toString方法

Module基本用法

CommonJS模塊就是對象，輸入時必須查找對象屬性。

var { stat, exists, readFile } = require(‘fs‘);

ES6模塊不是對象，而是通過export命令顯式指定輸出的代碼，輸入時也采用靜態命令的形式。

import { stat, exists, readFile } from ‘fs‘;

所以，ES6可以在編譯時就完成模塊編譯，效率要比CommonJS模塊高。

模塊功能主要由兩個命令構成：export和import。export命令用於用戶自定義模塊，規定對外接口；import命令用於輸入其他模塊提供的功能，同時創造命名空間（namespace），防止函數名沖突。文件內部的所有變量，外部無法獲取，必須使用export關鍵字輸出變量

eg:

// profile.js
export var firstName = ‘Michael‘;
export var lastName = ‘Jackson‘;
export var year = 1958;

或者

// profile.js
var firstName = ‘Michael‘;
var lastName = ‘Jackson‘;
var year = 1958;
export {firstName, lastName, year};

// main.js
import {firstName, lastName, year} from ‘./profile‘;
function sfirsetHeader(element) {
  element.textContent = firstName + ‘ ‘ + lastName;
 }
 大括號裏面的變量名，必須與被導入模塊（profile.js）對外接口的名稱相同。

如果想為輸入的變量重新取一個名字，import語句中要使用as關鍵字，將輸入的變量重命名。

import { lastName as surname } from ‘./profile‘;

export命令除了輸出變量，還可以輸出方法或類（class）。下面是一個circle.js文件，它輸出兩個方法area和circumference。

// circle.js
export function area(radius) {
  return Math.PI * radius * radius;
}

export function circumference(radius) {
  return 2 * Math.PI * radius;
}

然後，main.js輸入circlek.js模塊。

// main.js
import { area, circumference } from ‘circle‘;
console.log("圓面積：" + area(4));
console.log("圓周長：" + circumference(14));

上面寫法是逐一指定要輸入的方法。另一種寫法是整體輸入。

import * as circle from ‘circle‘;
console.log("圓面積：" + circle.area(4));
console.log("圓周長：" + circle.circumference(14));

module命令可以取代import語句，達到整體輸入模塊的作用。

// main.js

module circle from ‘circle‘;
console.log("圓面積：" + circle.area(4));
console.log("圓周長：" + circle.circumference(14));

如果想要輸出匿名函數，可以使用export default命令。

// export-default.js
export default function () {
    console.log(‘foo‘);
}

其他模塊輸入該模塊時，import命令可以為該匿名函數指定任意名字。

// import-default.js
import customName from ‘./export-default‘;
customName(); // ‘foo‘

上面代碼的import命令，可以用任意名稱指向輸出的匿名函數。需要註意的是，這時import命令後面，不使用大括號。

export default命令用在非匿名函數前，也是可以的。

// export-default.js
export default function foo() {
  console.log(‘foo‘);
}

// 或者寫成
function foo() {
  console.log(‘foo‘);
}

export default foo;

上面代碼中，foo函數的函數名foo，在模塊外部是無效的。加載的時候，視同匿名函數加載。

如果想在一條import語句中，同時輸入默認方法和其他變量，可以寫成下面這樣。

import customName, { otherMethod } from ‘./export-default‘;

如果要輸出默認的值，只需將值跟在export default之後即可。

export default 42;

export default也可以用來輸出類。

// MyClass.js

export default class { ... }

// main.js
import MyClass from ‘MyClass‘

let o = new MyClass();

模塊之間也可以繼承。

假設有一個circleplus模塊，繼承了circle模塊。

// circleplus.js
export * from ‘circle‘;
export var e = 2.71828182846;
export default function(x) {
    return Math.exp(x);
}

上面代碼中的“export *”，表示輸出circle模塊的所有屬性和方法，export default命令定義模塊的默認方法。

ES6筆記二