摘要：規(guī)范最終由敲定。提案由至少一名成員倡導的正式提案文件，該文件包括事例。箭頭函數(shù)這是中最令人激動的特性之一。數(shù)組拷貝等同于展開語法和行為一致執(zhí)行的都是淺拷貝只遍歷一層。不使用對象中必須包含屬性和值，顯得非常冗余。

ES全稱ECMAScript，ECMAScript是ECMA制定的標準化腳本語言。目前JavaScript使用的ECMAScript版本為ECMA-417。關于ECMA的最新資訊可以瀏覽
ECMA news查看。

ECMA規(guī)范最終由TC39敲定。TC39由包括瀏覽器廠商在內(nèi)的各方組成，他們開會推動JavaScript提案沿著一條嚴格的發(fā)展道路前進。 從提案到入選ECMA規(guī)范主要有以下幾個階段：

Stage 0: strawman——最初想法的提交。

Stage 1: proposal（提案）——由TC39至少一名成員倡導的正式提案文件，該文件包括API事例。

Stage 2: draft（草案）——功能規(guī)范的初始版本，該版本包含功能規(guī)范的兩個實驗實現(xiàn)。

Stage 3: candidate（候選）——提案規(guī)范通過審查并從廠商那里收集反饋

Stage 4: finished（完成）——提案準備加入ECMAScript，但是到瀏覽器或者Nodejs中可能需要更長的時間。

ES6的特性比較多，在 ES5 發(fā)布近 6 年（2009-11 至 2015-6）之后才將其標準化。兩個發(fā)布版本之間時間跨度很大，所以ES6中的特性比較多。 在這里列舉幾個常用的：

類

模塊化

箭頭函數(shù)

函數(shù)參數(shù)默認值

模板字符串

解構賦值

延展操作符

對象屬性簡寫

Promise

Let與Const

對熟悉Java，object-c，c#等純面向對象語言的開發(fā)者來說，都會對class有一種特殊的情懷。ES6 引入了class（類），讓JavaScript的面向對象編程變得更加簡單和易于理解。

  class Animal {
    // 構造函數(shù)，實例化的時候將會被調用，如果不指定，那么會有一個不帶參數(shù)的默認構造函數(shù).
    constructor(name,color) {
      this.name = name;
      this.color = color;
    }
    // toString 是原型對象上的屬性
    toString() {
      console.log("name:" + this.name + ",color:" + this.color);

    }
  }

 var animal = new Animal("dog","white");//實例化Animal
 animal.toString();

 console.log(animal.hasOwnProperty("name")); //true
 console.log(animal.hasOwnProperty("toString")); // false
 console.log(animal.__proto__.hasOwnProperty("toString")); // true

 class Cat extends Animal {
  constructor(action) {
    // 子類必須要在constructor中指定super 函數(shù)，否則在新建實例的時候會報錯.
    // 如果沒有置頂consructor,默認帶super函數(shù)的constructor將會被添加、
    super("cat","white");
    this.action = action;
  }
  toString() {
    console.log(super.toString());
  }
 }

 var cat = new Cat("catch")
 cat.toString();

 // 實例cat 是 Cat 和 Animal 的實例，和Es5完全一致。
 console.log(cat instanceof Cat); // true
 console.log(cat instanceof Animal); // true

ES5不支持原生的模塊化，在ES6中模塊作為重要的組成部分被添加進來。模塊的功能主要由 export 和 import 組成。每一個模塊都有自己多帶帶的作用域，模塊之間的相互調用關系是通過 export 來規(guī)定模塊對外暴露的接口，通過import來引用其它模塊提供的接口。同時還為模塊創(chuàng)造了命名空間，防止函數(shù)的命名沖突。

導出(export)

ES6允許在一個模塊中使用export來導出多個變量或函數(shù)。

導出變量

//test.js
export var name = "Rainbow"

心得：ES6不僅支持變量的導出，也支持常量的導出。 export const sqrt = Math.sqrt;//導出常量

ES6將一個文件視為一個模塊，上面的模塊通過 export 向外輸出了一個變量。一個模塊也可以同時往外面輸出多個變量。

 //test.js
 var name = "Rainbow";
 var age = "24";
 export {name, age};

導出函數(shù)

// myModule.js
export function myModule(someArg) {
  return someArg;
}  

導入(import)

定義好模塊的輸出以后就可以在另外一個模塊通過import引用。

import {myModule} from "myModule";// main.js
import {name,age} from "test";// test.js

心得:一條import 語句可以同時導入默認函數(shù)和其它變量。import defaultMethod, { otherMethod } from "xxx.js";

這是ES6中最令人激動的特性之一。=>不只是關鍵字function的簡寫，它還帶來了其它好處。箭頭函數(shù)與包圍它的代碼共享同一個this,能幫你很好的解決this的指向問題。有經(jīng)驗的JavaScript開發(fā)者都熟悉諸如var self = this;或var that = this這種引用外圍this的模式。但借助=>，就不需要這種模式了。

箭頭函數(shù)的結構

箭頭函數(shù)的箭頭=>之前是一個空括號、單個的參數(shù)名、或用括號括起的多個參數(shù)名，而箭頭之后可以是一個表達式（作為函數(shù)的返回值），或者是用花括號括起的函數(shù)體（需要自行通過return來返回值，否則返回的是undefined）。

// 箭頭函數(shù)的例子
()=>1
v=>v+1
(a,b)=>a+b
()=>{
    alert("foo");
}
e=>{
    if (e == 0){
        return 0;
    }
    return 1000/e;
}

心得：不論是箭頭函數(shù)還是bind，每次被執(zhí)行都返回的是一個新的函數(shù)引用，因此如果你還需要函數(shù)的引用去做一些別的事情（譬如卸載監(jiān)聽器），那么你必須自己保存這個引用。

卸載監(jiān)聽器時的陷阱

錯誤的做法

class PauseMenu extends React.Component{
    componentWillMount(){
        AppStateIOS.addEventListener("change", this.onAppPaused.bind(this));
    }
    componentWillUnmount(){
        AppStateIOS.removeEventListener("change", this.onAppPaused.bind(this));
    }
    onAppPaused(event){
    }
}

正確的做法

class PauseMenu extends React.Component{
    constructor(props){
        super(props);
        this._onAppPaused = this.onAppPaused.bind(this);
    }
    componentWillMount(){
        AppStateIOS.addEventListener("change", this._onAppPaused);
    }
    componentWillUnmount(){
        AppStateIOS.removeEventListener("change", this._onAppPaused);
    }
    onAppPaused(event){
    }
}

除上述的做法外，我們還可以這樣做：

class PauseMenu extends React.Component{
    componentWillMount(){
        AppStateIOS.addEventListener("change", this.onAppPaused);
    }
    componentWillUnmount(){
        AppStateIOS.removeEventListener("change", this.onAppPaused);
    }
    onAppPaused = (event) => {
        //把函數(shù)直接作為一個arrow function的屬性來定義，初始化的時候就綁定好了this指針
    }
}

需要注意的是：不論是bind還是箭頭函數(shù)，每次被執(zhí)行都返回的是一個新的函數(shù)引用，因此如果你還需要函數(shù)的引用去做一些別的事情（譬如卸載監(jiān)聽器），那么你必須自己保存這個引用。

ES6支持在定義函數(shù)的時候為其設置默認值：

function foo(height = 50, color = "red")
{
    // ...
}

不使用默認值：

function foo(height, color)
{
    var height = height || 50;
    var color = color || "red";
    //...
}

這樣寫一般沒問題，但當參數(shù)的布爾值為false時，就會有問題了。比如，我們這樣調用foo函數(shù)：

foo(0, "")

因為0的布爾值為false，這樣height的取值將是50。同理color的取值為‘red’。

所以說，函數(shù)參數(shù)默認值不僅能是代碼變得更加簡潔而且能規(guī)避一些問題。

ES6支持模板字符串，使得字符串的拼接更加的簡潔、直觀。

不使用模板字符串：

var name = "Your name is " + first + " " + last + "."

使用模板字符串：

var name = `Your name is ${first} ${last}.`

在ES6中通過${}就可以完成字符串的拼接，只需要將變量放在大括號之中。

解構賦值語法是JavaScript的一種表達式，可以方便的從數(shù)組或者對象中快速提取值賦給定義的變量。

獲取數(shù)組中的值

從數(shù)組中獲取值并賦值到變量中，變量的順序與數(shù)組中對象順序對應。

var foo = ["one", "two", "three", "four"];

var [one, two, three] = foo;
console.log(one); // "one"
console.log(two); // "two"
console.log(three); // "three"

//如果你要忽略某些值，你可以按照下面的寫法獲取你想要的值
var [first, , , last] = foo;
console.log(first); // "one"
console.log(last); // "four"

//你也可以這樣寫
var a, b; //先聲明變量

[a, b] = [1, 2];
console.log(a); // 1
console.log(b); // 2

如果沒有從數(shù)組中的獲取到值，你可以為變量設置一個默認值。

var a, b;

[a=5, b=7] = [1];
console.log(a); // 1
console.log(b); // 7

通過解構賦值可以方便的交換兩個變量的值。

var a = 1;
var b = 3;

[a, b] = [b, a];
console.log(a); // 3
console.log(b); // 1

獲取對象中的值

const student = {
  name:"Ming",
  age:"18",
  city:"Shanghai"  
};

const {name,age,city} = student;
console.log(name); // "Ming"
console.log(age); // "18"
console.log(city); // "Shanghai"

延展操作符...可以在函數(shù)調用/數(shù)組構造時, 將數(shù)組表達式或者string在語法層面展開；還可以在構造對象時, 將對象表達式按key-value的方式展開。

語法

函數(shù)調用：

myFunction(...iterableObj);

數(shù)組構造或字符串：

[...iterableObj, "4", ..."hello", 6];

構造對象時,進行克隆或者屬性拷貝（ECMAScript 2018規(guī)范新增特性）：

let objClone = { ...obj };

應用場景

在函數(shù)調用時使用延展操作符

function sum(x, y, z) {
  return x + y + z;
}
const numbers = [1, 2, 3];

//不使用延展操作符
console.log(sum.apply(null, numbers));

//使用延展操作符
console.log(sum(...numbers));// 6

構造數(shù)組

沒有展開語法的時候，只能組合使用 push，splice，concat 等方法，來將已有數(shù)組元素變成新數(shù)組的一部分。有了展開語法, 構造新數(shù)組會變得更簡單、更優(yōu)雅：

const stuendts = ["Jine","Tom"]; 
const persons = ["Tony",... stuendts,"Aaron","Anna"];
conslog.log(persions)// ["Tony", "Jine", "Tom", "Aaron", "Anna"]

和參數(shù)列表的展開類似, ... 在構造字數(shù)組時, 可以在任意位置多次使用。

數(shù)組拷貝

var arr = [1, 2, 3];
var arr2 = [...arr]; // 等同于 arr.slice()
arr2.push(4); 
console.log(arr2)//[1, 2, 3, 4]

展開語法和 Object.assign() 行為一致, 執(zhí)行的都是淺拷貝(只遍歷一層)。

連接多個數(shù)組

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
var arr3 = [...arr1, ...arr2];// 將 arr2 中所有元素附加到 arr1 后面并返回
//等同于
var arr4 = arr1.concat(arr2);

在ECMAScript 2018中延展操作符增加了對對象的支持

var obj1 = { foo: "bar", x: 42 };
var obj2 = { foo: "baz", y: 13 };

var clonedObj = { ...obj1 };
// 克隆后的對象: { foo: "bar", x: 42 }

var mergedObj = { ...obj1, ...obj2 };
// 合并后的對象: { foo: "baz", x: 42, y: 13 }

在React中的應用

通常我們在封裝一個組件時，會對外公開一些 props 用于實現(xiàn)功能。大部分情況下在外部使用都應顯示的傳遞 props 。但是當傳遞大量的props時，會非常繁瑣，這時我們可以使用 ...(延展操作符,用于取出參數(shù)對象的所有可遍歷屬性) 來進行傳遞。

一般情況下我們應該這樣寫

"Jine" age ={21} />

使用 ... ，等同于上面的寫法

const params = {
	name: "Jine",
	age: 21
}

配合解構賦值避免傳入一些不需要的參數(shù)

var params = {
	name: "123",
	title: "456",
	type: "aaa"
}

var { type, ...other } = params;


//等同于

在ES6中允許我們在設置一個對象的屬性的時候不指定屬性名。

不使用ES6

const name="Ming",age="18",city="Shanghai";
   
const student = {
    name:name,
    age:age,
    city:city
};
console.log(student);//{name: "Ming", age: "18", city: "Shanghai"}

對象中必須包含屬性和值，顯得非常冗余。

使用ES6

const name="Ming",age="18",city="Shanghai";
  
const student = {
    name,
    age,
    city
};
console.log(student);//{name: "Ming", age: "18", city: "Shanghai"}

對象中直接寫變量，非常簡潔。

Promise 是異步編程的一種解決方案，比傳統(tǒng)的解決方案callback更加的優(yōu)雅。它最早由社區(qū)提出和實現(xiàn)的，ES6 將其寫進了語言標準，統(tǒng)一了用法，原生提供了Promise對象。

不使用ES6

嵌套兩個setTimeout回調函數(shù)：

setTimeout(function()
{
    console.log("Hello"); // 1秒后輸出"Hello"
    setTimeout(function()
    {
        console.log("Hi"); // 2秒后輸出"Hi"
    }, 1000);
}, 1000);

使用ES6

var waitSecond = new Promise(function(resolve, reject)
{
    setTimeout(resolve, 1000);
});

waitSecond
    .then(function()
    {
      console.log("Hello"); // 1秒后輸出"Hello"
      return waitSecond;
    })
    .then(function()
    {
        console.log("Hi"); // 2秒后輸出"Hi"
    });

上面的的代碼使用兩個then來進行異步編程串行化，避免了回調地獄：

在之前JS是沒有塊級作用域的，const與let填補了這方便的空白，const與let都是塊級作用域。

使用var定義的變量為函數(shù)級作用域：

{
  var a = 10;
}

console.log(a); // 輸出10

使用let與const定義的變量為塊級作用域：

{
  let a = 10;
}

console.log(a); //-1 or Error“ReferenceError: a is not defined”

ES2016添加了兩個小的特性來說明標準化過程：

數(shù)組includes()方法，用來判斷一個數(shù)組是否包含一個指定的值，根據(jù)情況，如果包含則返回true，否則返回false。

a ** b指數(shù)運算符，它與 Math.pow(a, b)相同。

includes() 函數(shù)用來判斷一個數(shù)組是否包含一個指定的值，如果包含則返回 true，否則返回false。

includes 函數(shù)與 indexOf 函數(shù)很相似，下面兩個表達式是等價的：

arr.includes(x)
arr.indexOf(x) >= 0

接下來我們來判斷數(shù)字中是否包含某個元素：

在ES7之前的做法

使用indexOf()驗證數(shù)組中是否存在某個元素，這時需要根據(jù)返回值是否為-1來判斷：

let arr = ["react", "angular", "vue"];

if (arr.indexOf("react") !== -1)
{
    console.log("react存在");
}

使用ES7的includes()

使用includes()驗證數(shù)組中是否存在某個元素，這樣更加直觀簡單：

let arr = ["react", "angular", "vue"];

if (arr.includes("react"))
{
    console.log("react存在");
}

在ES7中引入了指數(shù)運算符**，**具有與Math.pow(..)等效的計算結果。

不使用指數(shù)操作符

使用自定義的遞歸函數(shù)calculateExponent或者Math.pow()進行指數(shù)運算：

function calculateExponent(base, exponent)
{
    if (exponent === 1)
    {
        return base;
    }
    else
    {
        return base * calculateExponent(base, exponent - 1);
    }
}

console.log(calculateExponent(2, 10)); // 輸出1024
console.log(Math.pow(2, 10)); // 輸出1024

使用指數(shù)操作符

使用指數(shù)運算符**，就像+、-等操作符一樣：

console.log(2**10);// 輸出1024

async/await

Object.values()

Object.entries()

String padding: padStart()和padEnd()，填充字符串達到當前長度

函數(shù)參數(shù)列表結尾允許逗號

Object.getOwnPropertyDescriptors()

ShareArrayBuffer和Atomics對象，用于從共享內(nèi)存位置讀取和寫入

ES2018引入異步迭代器（asynchronous iterators），這就像常規(guī)迭代器，除了next()方法返回一個Promise。因此await可以和for...of循環(huán)一起使用，以串行的方式運行異步操作。例如：

async function process(array) {
  for await (let i of array) {
    doSomething(i);
  }
}

Object.values()是一個與Object.keys()類似的新函數(shù)，但返回的是Object自身屬性的所有值，不包括繼承的值。

假設我們要遍歷如下對象obj的所有值：

const obj = {a: 1, b: 2, c: 3};

不使用Object.values() :ES7

const vals=Object.keys(obj).map(key=>obj[key]);
console.log(vals);//[1, 2, 3]

使用Object.values() :ES8

const values=Object.values(obj1);
console.log(values);//[1, 2, 3]

從上述代碼中可以看出Object.values()為我們省去了遍歷key，并根據(jù)這些key獲取value的步驟。

Object.entries()函數(shù)返回一個給定對象自身可枚舉屬性的鍵值對的數(shù)組。

接下來我們來遍歷上文中的obj對象的所有屬性的key和value：

不使用Object.entries() :ES7

Object.keys(obj).forEach(key=>{
	console.log("key:"+key+" value:"+obj[key]);
})
//key:a value:1
//key:b value:2
//key:c value:3

使用Object.entries() :ES8

for(let [key,value] of Object.entries(obj1)){
	console.log(`key: ${key} value:${value}`)
}
//key:a value:1
//key:b value:2
//key:c value:3

在ES8中String新增了兩個實例函數(shù)String.prototype.padStart和String.prototype.padEnd，允許將空字符串或其他字符串添加到原始字符串的開頭或結尾。

String.padStart(targetLength,[padString])

targetLength:當前字符串需要填充到的目標長度。如果這個數(shù)值小于當前字符串的長度，則返回當前字符串本身。

padString:(可選)填充字符串。如果字符串太長，使填充后的字符串長度超過了目標長度，則只保留最左側的部分，其他部分會被截斷，此參數(shù)的缺省值為 " "。

console.log("0.0".padStart(4,"10")) //10.0
console.log("0.0".padStart(20))// 0.00    

String.padEnd(targetLength,padString])

targetLength:當前字符串需要填充到的目標長度。如果這個數(shù)值小于當前字符串的長度，則返回當前字符串本身。

padString:(可選) 填充字符串。如果字符串太長，使填充后的字符串長度超過了目標長度，則只保留最左側的部分，其他部分會被截斷，此參數(shù)的缺省值為 " "；

console.log("0.0".padEnd(4,"0")) //0.00    
console.log("0.0".padEnd(10,"0"))//0.00000000

主要作用是方便使用git進行多人協(xié)作開發(fā)時修改同一個函數(shù)減少不必要的行變更。

Object.getOwnPropertyDescriptors()函數(shù)用來獲取一個對象的所有自身屬性的描述符,如果沒有任何自身屬性，則返回空對象。

函數(shù)原型：

Object.getOwnPropertyDescriptors(obj)

返回obj對象的所有自身屬性的描述符，如果沒有任何自身屬性，則返回空對象。

const obj2 = {
	name: "Jine",
	get age() { return "18" }
};
Object.getOwnPropertyDescriptors(obj2)
// {
//   age: {
//     configurable: true,
//     enumerable: true,
//     get: function age(){}, //the getter function
//     set: undefined
//   },
//   name: {
//     configurable: true,
//     enumerable: true,
//		value:"Jine",
//		writable:true
//   }
// }

SharedArrayBuffer 對象用來表示一個通用的，固定長度的原始二進制數(shù)據(jù)緩沖區(qū)，類似于 ArrayBuffer 對象，它們都可以用來在共享內(nèi)存（shared memory）上創(chuàng)建視圖。與 ArrayBuffer 不同的是，SharedArrayBuffer 不能被分離。

/**
 * 
 * @param {*} length 所創(chuàng)建的數(shù)組緩沖區(qū)的大小，以字節(jié)(byte)為單位。  
 * @returns {SharedArrayBuffer} 一個大小指定的新 SharedArrayBuffer 對象。其內(nèi)容被初始化為 0。
 */
new SharedArrayBuffer(length)

Atomics 對象提供了一組靜態(tài)方法用來對 SharedArrayBuffer 對象進行原子操作。

這些原子操作屬于 Atomics 模塊。與一般的全局對象不同，Atomics 不是構造函數(shù)，因此不能使用 new 操作符調用，也不能將其當作函數(shù)直接調用。Atomics 的所有屬性和方法都是靜態(tài)的（與 Math 對象一樣）。

多個共享內(nèi)存的線程能夠同時讀寫同一位置上的數(shù)據(jù)。原子操作會確保正在讀或寫的數(shù)據(jù)的值是符合預期的，即下一個原子操作一定會在上一個原子操作結束后才會開始，其操作過程不會中斷。

Atomics.add()

將指定位置上的數(shù)組元素與給定的值相加，并返回相加前該元素的值。

Atomics.and()

將指定位置上的數(shù)組元素與給定的值相與，并返回與操作前該元素的值。

Atomics.compareExchange()

如果數(shù)組中指定的元素與給定的值相等，則將其更新為新的值，并返回該元素原先的值。

Atomics.exchange()

將數(shù)組中指定的元素更新為給定的值，并返回該元素更新前的值。

Atomics.load()

返回數(shù)組中指定元素的值。

Atomics.or()

將指定位置上的數(shù)組元素與給定的值相或，并返回或操作前該元素的值。

Atomics.store()

將數(shù)組中指定的元素設置為給定的值，并返回該值。

Atomics.sub()

將指定位置上的數(shù)組元素與給定的值相減，并返回相減前該元素的值。

Atomics.xor()

將指定位置上的數(shù)組元素與給定的值相異或，并返回異或操作前該元素的值。

wait() 和 wake() 方法采用的是 Linux 上的 futexes 模型（fast user-space mutex，快速用戶空間互斥量），可以讓進程一直等待直到某個特定的條件為真，主要用于實現(xiàn)阻塞。

Atomics.wait()

檢測數(shù)組中某個指定位置上的值是否仍然是給定值，是則保持掛起直到被喚醒或超時。返回值為 "ok"、"not-equal" 或 "time-out"。調用時，如果當前線程不允許阻塞，則會拋出異常（大多數(shù)瀏覽器都不允許在主線程中調用 wait()）。

Atomics.wake()

喚醒等待隊列中正在數(shù)組指定位置的元素上等待的線程。返回值為成功喚醒的線程數(shù)量。

Atomics.isLockFree(size)

可以用來檢測當前系統(tǒng)是否支持硬件級的原子操作。對于指定大小的數(shù)組，如果當前系統(tǒng)支持硬件級的原子操作，則返回 true；否則就意味著對于該數(shù)組，Atomics 對象中的各原子操作都只能用鎖來實現(xiàn)。此函數(shù)面向的是技術專家。-->

異步迭代

Promise.finally()

Rest/Spread 屬性

正則表達式命名捕獲組（Regular Expression Named Capture Groups）

正則表達式反向斷言（lookbehind）

正則表達式dotAll模式

正則表達式 Unicode 轉義

非轉義序列的模板字符串

在async/await的某些時刻，你可能嘗試在同步循環(huán)中調用異步函數(shù)。例如：

async function process(array) {
  for (let i of array) {
    await doSomething(i);
  }
}

這段代碼不會正常運行，下面這段同樣也不會：

async function process(array) {
  array.forEach(async i => {
    await doSomething(i);
  });
}

這段代碼中，循環(huán)本身依舊保持同步，并在在內(nèi)部異步函數(shù)之前全部調用完成。

ES2018引入異步迭代器（asynchronous iterators），這就像常規(guī)迭代器，除了next()方法返回一個Promise。因此await可以和for...of循環(huán)一起使用，以串行的方式運行異步操作。例如：

async function process(array) {
  for await (let i of array) {
    doSomething(i);
  }
}

一個Promise調用鏈要么成功到達最后一個.then()，要么失敗觸發(fā).catch()。在某些情況下，你想要在無論Promise運行成功還是失敗，運行相同的代碼，例如清除，刪除對話，關閉數(shù)據(jù)庫連接等。

.finally()允許你指定最終的邏輯：

function doSomething() {
  doSomething1()
  .then(doSomething2)
  .then(doSomething3)
  .catch(err => {
    console.log(err);
  })
  .finally(() => {
    // finish here!
  });
}

ES2015引入了Rest參數(shù)和擴展運算符。三個點（...）僅用于數(shù)組。Rest參數(shù)語法允許我們將一個不定數(shù)量的參數(shù)表示為一個數(shù)組。

restParam(1, 2, 3, 4, 5);

function restParam(p1, p2, ...p3) {
  // p1 = 1
  // p2 = 2
  // p3 = [3, 4, 5]
}

展開操作符以相反的方式工作，將數(shù)組轉換成可傳遞給函數(shù)的多帶帶參數(shù)。例如Math.max()返回給定數(shù)字中的最大值：

const values = [99, 100, -1, 48, 16];
console.log( Math.max(...values) ); // 100

ES2018為對象解構提供了和數(shù)組一樣的Rest參數(shù)（）和展開操作符，一個簡單的例子：

const myObject = {
  a: 1,
  b: 2,
  c: 3
};

const { a, ...x } = myObject;
// a = 1
// x = { b: 2, c: 3 }

或者你可以使用它給函數(shù)傳遞參數(shù)：

restParam({
  a: 1,
  b: 2,
  c: 3
});

function restParam({ a, ...x }) {
  // a = 1
  // x = { b: 2, c: 3 }
}

跟數(shù)組一樣，Rest參數(shù)只能在聲明的結尾處使用。此外，它只適用于每個對象的頂層，如果對象中嵌套對象則無法適用。

擴展運算符可以在其他對象內(nèi)使用，例如：

const obj1 = { a: 1, b: 2, c: 3 };
const obj2 = { ...obj1, z: 26 };
// obj2 is { a: 1, b: 2, c: 3, z: 26 }

可以使用擴展運算符拷貝一個對象，像是這樣obj2 = {...obj1}，但是 這只是一個對象的淺拷貝。另外，如果一個對象A的屬性是對象B，那么在克隆后的對象cloneB中，該屬性指向對象B。

JavaScript正則表達式可以返回一個匹配的對象——一個包含匹配字符串的類數(shù)組，例如：以YYYY-MM-DD的格式解析日期：

const
  reDate = /([0-9]{4})-([0-9]{2})-([0-9]{2})/,
  match  = reDate.exec("2018-04-30"),
  year   = match[1], // 2018
  month  = match[2], // 04
  day    = match[3]; // 30

這樣的代碼很難讀懂，并且改變正則表達式的結構有可能改變匹配對象的索引。

ES2018允許命名捕獲組使用符號");，在打開捕獲括號(后立即命名，示例如下：

const
  reDate = /(");,
  match  = reDate.exec("2018-04-30"),
  year   = match.groups.year,  // 2018
  month  = match.groups.month, // 04
  day    = match.groups.day;   // 30

const
  reDate = /(");,
  d      = "2018-04-30",
  usDate = d.replace(reDate, "$-$-$");

const
  reLookahead = /D(");,
  match       = reLookahead.exec("$123.89");

console.log( match[0] ); // $

const
  reLookbehind = /(");,
  match        = reLookbehind.exec("$123.89");

console.log( match[0] ); // 123.89

const
  reLookbehindNeg = /(");,
  match           = reLookbehind.exec("$123.89");

console.log( match[0] ); // null

/hello.world/.test("hello
world");  // false
/hello.world/s.test("hello
world"); // true

const reGreekSymbol = /p{Script=Greek}/u;
reGreekSymbol.test("π"); // true

var arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]

var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

//使用 Infinity 作為深度，展開任意深度的嵌套數(shù)組
arr3.flat(Infinity); 
// [1, 2, 3, 4, 5, 6]

var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]

var arr1 = [1, 2, 3, 4];

arr1.map(x => [x * 2]); 
// [[2], [4], [6], [8]]

arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]

// 只會將 flatMap 中的函數(shù)返回的數(shù)組 “壓平” 一層
arr1.flatMap(x => [[x * 2]]);
// [[2], [4], [6], [8]]

const map = new Map([ ["foo", "bar"], ["baz", 42] ]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }

const arr = [ ["0", "a"], ["1", "b"], ["2", "c"] ];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }

const sym = Symbol("The description");

assert.equal(String(sym), "Symbol(The description)");

assert.equal(sym.description, "The description");

const regexp = RegExp("foo*","g");
const str = "table football, foosball";

while ((matches = regexp.exec(str)) !== null) {
  console.log(`Found ${matches[0]}. Next starts at ${regexp.lastIndex}.`);
  // expected output: "Found foo. Next starts at 9."
  // expected output: "Found foo. Next starts at 19."
}

const regexp = RegExp("foo*","g"); 
const str = "table football, foosball";
let matches = str.matchAll(regexp);

for (const match of matches) {
  console.log(match);
}
// Array [ "foo" ]
// Array [ "foo" ]

// matches iterator is exhausted after the for..of iteration
// Call matchAll again to create a new iterator
matches = str.matchAll(regexp);

Array.from(matches, m => m[0]);
// Array [ "foo", "foo" ]

var regexp = /t(e)(st(d");;
var str = "test1test2";

str.match(regexp); 
// Array ["test1", "test2"]

let array = [...str.matchAll(regexp)];

array[0];
// ["test1