ES7

1.Array.prototype.includes()
includes()作用,是查找一個值在不在數(shù)組里,若是存在則返回true,不存在返回false.

[1,2,3,4].includes(4) // true

• 只能判斷簡單類型的數(shù)據(jù)，對于復雜類型的數(shù)據(jù)，比如對象類型的數(shù)組收擦，二維數(shù)組竿痰，這些灾搏，是無法判斷的.

• 對于NaN的處理結(jié)果不同(js中 NaN === NaN 的結(jié)果是false,indexOf()也是這樣處理的定续，但是includes()不是這樣的慈鸠。)

[1,2,NaN].indexOf(NaN) // -1
[1,2,NaN].includes(NaN) // true
NaN === NaN // false

2.求冪運算符

2**3 //8
var a = 3; a**=2; // a === 9

ES8

1. async await
異步函數(shù)存在以下四種使用形式：

• 函數(shù)聲明： async function foo() {}
• 函數(shù)表達式： const foo = async function() {}
• 對象的方式： let obj = { async foo() {} }
• 箭頭函數(shù)： const foo = async () => {}

async用于定義一個異步函數(shù)御雕，該函數(shù)返回一個Promise蛔屹。
如果async函數(shù)返回的是一個同步的值削樊，這個值將被包裝成一個理解resolve的Promise，等同于return Promise.resolve(value)兔毒。
await用于一個異步操作之前漫贞，表示要“等待”這個異步操作的返回值。await也可以用于一個同步的值育叁。

function 搖色子(){
    return new Promise((resolve, reject)=>{
        let sino = parseInt(Math.random() * 6 +1)
        setTimeout(()=>{
            resolve(sino)
        },3000)
    })
}
async function test(){
    let n =await 搖色子()
    console.log(n)
}
test()

2. Object.entries()
作用：將一個對象中可枚舉屬性的鍵名和鍵值按照二維數(shù)組的方式返回迅脐。
若對象是數(shù)組，則會將數(shù)組的下標作為鍵值返回豪嗽。

Object.entries({ one: 1, two: 2 })    //[['one', 1], ['two', 2]]
Object.entries([1, 2])                //[['0', 1], ['1', 2]]

要點
2.1 若是鍵名是Symbol谴蔑，編譯時會被自動忽略

Object.entries({[Symbol()]:1, two: 2})  //[['two', 2]]

2.2 entries()返回的數(shù)組順序和for循環(huán)一樣，即如果對象的key值是數(shù)字龟梦，則返回值會對key值進行排序隐锭，返回的是排序后的結(jié)果

Object.entries({ 3: 'a', 4: 'b', 1: 'c' })    //[['1', 'c'], ['3', 'a'], ['4', 'b']]

2.3利用Object.entries()創(chuàng)建一個真正的Map

    var obj = { foo: 'bar', baz: 42 };
    
    var map1 = new Map([['foo', 'bar'], ['baz', 42]]); //原本的創(chuàng)建方式
    var map2 = new Map(Object.entries(obj));    //等同于map1

    console.log(map1);// Map { foo: "bar", baz: 42 }
    console.log(map2);// Map { foo: "bar", baz: 42 }

3.Object.values()
只返回自己的鍵值對中屬性的值。它返回的數(shù)組順序计贰，也跟Object.entries()保持一致

Object.values({ one: 1, two: 2 })            //[1, 2]
Object.values({ 3: 'a', 4: 'b', 1: 'c' })    //['c', 'a', 'b']

4. 字符串填充
字符串填充padStart()和padEnd()

用法
String.padStart(targetLength, padding)
參數(shù)：字符串目標長度和填充字段

'Vue'.padStart(10)           //'       Vue'
'React'.padStart(10)         //'     React'
'JavaScript'.padStart(10)    //'JavaScript'

'Vue'.padEnd(10, '_*')           //'Vue_*_*_*_'
'React'.padEnd(10, 'Hello')      //'ReactHello'
'JavaScript'.padEnd(10, 'Hi')    //'JavaScript'
'JavaScript'.padEnd(8, 'Hi')     //'JavaScript'

5.Object.getOwnPropertyDescriptors()
該方法會返回目標對象中所有屬性的屬性描述符钦睡，該屬性必須是對象自己定義的，不能是從原型鏈繼承來的
如果沒有任何自身屬性蹦玫，則返回空對象赎婚。

    var obj = {
        id:  1,
        name: '霖呆呆',
        get gender() {
            console.log('gender')
        },
        set grad(d) {
            console.log(d)
        }
    }
    console.log(Object.getOwnPropertyDescriptors(obj))
 //輸出   
{
  gender: {
    configurable: true,
    enumerable: true,
    get: f gender(),
    set: undefined
  },
  grade: {
    configurable: true,
    enumerable: true,
    get: undefined,
    set: f grade(g)
  },
  id: {
    configurable: true,
    enumerable: true,
    value: 1,
    writable: true
  },
  name: {
    configurable: true,
    enumerable: true,
    value: '霖呆呆',
    writable: true
  }
}

與getOwnPropertyDescriptor()比較

var obj = {
    id: 1,
    name: '霖呆呆',
    get gender() {
        console.log('gender')
    },
    set grad(d) {
        console.log(d)
    }
}
console.log(Object.getOwnPropertyDescriptor(obj, 'id'))
        
//輸出結(jié)果
 {
  id: {
    configurable: true,
    enumerable: true,
    value: 1,
    writable: true
  }
}

兩者的區(qū)別：一個是只返回知道屬性名的描述對象,一個返回目標對象所有自身屬性的描述對象

7. ShareArrayBuffer

ShareArrayBuffer對象用來表示一個泛型的，固定長度的原生二進制數(shù)據(jù)緩沖區(qū)樱溉，類似于ArrayBuffer對象挣输。但在某種程度上，它們能被用于在共享內(nèi)存上創(chuàng)建視圖福贞。與ArrayBuffer不同的是撩嚼，ShareArrayBuffer不能被移除。

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

8.Atomics對象

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

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

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

• Atomics.add（）靜態(tài)方法會將給定的值加到數(shù)組里的某個特定位置上，并返回該位置的舊值采盒。此原子操作保證在寫上修改的值之前不會發(fā)生其他寫操作旧乞。
  語法： Atomics.add(typedArray, index, value)

• Atomics.load() 靜態(tài)方法 Atomics.load() 返回一個數(shù)組當中給定位置的值。
  語法： Atomics.load(typedArray, index)

• Atomics.and()靜態(tài)方法會將給定的值與數(shù)組上的值進行按位與操作磅氨，并將結(jié)果賦值給數(shù)組良蛮，然后返回數(shù)組該位置上的舊值。此原子操作保證在寫上修改的值之前不會發(fā)生其他寫操作悍赢。
  語法： Atomics.and(typedArray, index, value)

• Atomics.or()方法計算數(shù)組中給定位置的按位或給定值, 并返回該位置的舊值。此原子操作保證在修改后的值被寫回之前不會發(fā)生其他寫入货徙。
  語法：Atomics.or(typedArray, index, value)

• Atomics.compareExchange()靜態(tài)方法會在數(shù)組的值與期望值相等的時候左权，將給定的替換值替換掉數(shù)組上的值,然后返回舊值。此原子操作保證在寫上修改的值之前不會發(fā)生其他寫操作痴颊。
  語法： Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)

• Atomics.exchange() 靜態(tài)方法會用 給定的值替換掉數(shù)組上的值赏迟，然后返回數(shù)組的舊值。此原子操作保證在寫上修改的值之前不會發(fā)生其他寫操作蠢棱。
  語法： Atomics.exchange(typedArray, index, value)

• 靜態(tài)的Atomics.store（）方法將給定的值存儲在數(shù)組中的指定位置锌杀，并返回該值。
  語法： Atomics.store(typedArray, index, value)

• 靜態(tài)方法Atomics.sub() 減去數(shù)組中給定位置的給定值泻仙，并在該位置返回舊值糕再。這種原子操作保證了只有修改后的值被寫回，才能進行其他的寫操作玉转。
  語法：Atomics.sub(typedArray, index, value)

• Atomics.wake()方法喚醒在等待隊列中休眠的某些代理
  語法：Atomics.wake(typedArray, index, count)

ES9

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

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

2. Promise.finally()
一個Promise調(diào)用鏈要么成功到達最后一個.then()刺下，要么失敗觸發(fā).catch()绑嘹。在某些情況下，你想要在無論Promise運行成功還是失敗橘茉，運行相同的代碼

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

3.Rest/Spread 屬性
ES2015引入了Rest參數(shù)和擴展運算符工腋。三個點（...）僅用于數(shù)組

ES2018為對象解構(gòu)提供了和數(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 }
}

4.正則表達式命名捕獲組
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

這樣的代碼很難讀懂，并且改變正則表達式的結(jié)構(gòu)有可能改變匹配對象的索引夷蚊。
ES2018允許命名捕獲組使用符號?<name>构挤，在打開捕獲括號(后立即命名，示例如下：

const
  reDate = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/,
  match  = reDate.exec('2018-04-30'),
  year   = match.groups.year,  // 2018
  month  = match.groups.month, // 04
  day    = match.groups.day;   // 30

任何匹配失敗的命名組都將返回undefined惕鼓。
命名捕獲也可以使用在replace()方法中筋现。例如將日期轉(zhuǎn)換為美國的 MM-DD-YYYY 格式：

const
  reDate = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/,
  d      = '2018-04-30',
  usDate = d.replace(reDate, '$<month>-$<day>-$<year>');

5. 正則表達式反向斷言
js使用正則，對前瞻斷言和后瞻斷言的理解（轉(zhuǎn)發(fā)）
目前JavaScript在正則表達式中支持先行斷言（lookahead）箱歧。這意味著匹配會發(fā)生矾飞，但不會有任何捕獲，并且斷言沒有包含在整個匹配字段中呀邢。例如從價格中捕獲貨幣符號

const
  reLookahead = /\D(?=\d+)/,
  match       = reLookahead.exec('$123.89');

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

ES2018引入以相同方式工作但是匹配前面的反向斷言（lookbehind）洒沦，這樣我就可以忽略貨幣符號，單純的捕獲價格的數(shù)字：

const
  reLookbehind = /(?<=\D)\d+/,
  match        = reLookbehind.exec('$123.89');

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

斷言寫法
前瞻斷言
(?=exp) 順序肯定環(huán)視价淌，表示所在位置右側(cè)能夠匹配exp
(?!exp) 順序否定環(huán)視申眼，表示所在位置右側(cè)不能匹配exp

后瞻斷言
(?<=exp) 逆序肯定環(huán)視，表示所在位置左側(cè)能夠匹配exp
(?<!exp) 逆序否定環(huán)視蝉衣，表示所在位置左側(cè)不能匹配exp

6. 正則表達式dotAll模式
正則表達式中點.匹配除回車外的任何單字符括尸，標記s改變這種行為，允許行終止符的出現(xiàn)病毡，例如：(我的理解是有正則 /./s 中 .就可以代表任一單字符了)

/hello.world/.test('hello\nworld');  // false
/hello.world/s.test('hello\nworld'); // true

ES10

1.String.prototype.trimStart() / String.prototype.trimEnd()
ES5來濒翻，String.prototype.trim()被用于去除頭尾上的空格、換行符等啦膜，現(xiàn)在通過trimStart()有送，trimEnd()來頭和尾進行單獨控制

const string = ' Hello ES2019! ';
string.trimStart();
// 'Hello ES2019! '
string.trimEnd();
// ' Hello ES2019!'

2. Object.fromEntries()
ES8為我們引入了Object.entries把一個對象轉(zhuǎn)為[key, value]鍵值對的形式，可以運用于像 Map 這種結(jié)構(gòu)中僧家。凡事有來有回雀摘，Object.fromEntries()用于把鍵值對還原成對象結(jié)構(gòu)。

const entries = [ ['foo', 'bar'] ];
const object = Object.fromEntries(entries);
// { foo: 'bar' }

3.Array.prototype.flat() / Array.prototype.flatMap()
把數(shù)組展平是Array原型給我們帶來的新特性八拱，通過傳入層級深度參數(shù)（默認為1）届宠，來為下層數(shù)組提升層級。如果想提升所有層級可以寫一個比較大的數(shù)字甚至是Infinity

[1, 2, [3, 4]].flat();
// [ 1, 2, 3, 4 ]
[1, 2, [3, 4, [5, 6]]].flat(2);
// [ 1, 2, 3, 4, 5, 6 ]
[1, 2, [3, 4]].flat(Infinity); // [1, 2, 3, 4]

Array.prototype.flatMap()它是Array.prototype.map()和Array.prototype.flat()的組合乘粒，通過對map調(diào)整后的數(shù)據(jù)嘗試展平操作豌注。

[1, 2, [3, 4]].flatMap(v => {
  if (typeof v === 'number') {
    return v * 2
  } else {
    return v.map(v => v * 2)
  }
})
// [2, 4, 6, 8]

4. catch 的參數(shù)改為可選
在進行try...catch錯誤處理過程中，不用必須catch傳參數(shù),省略catch綁定的參數(shù)和括號

const isValidJSON = json => {
  try {
    JSON.parse(json);
    return true;
  } catch {
    return false;
  }
};

5.Symbol.description
Symbol是ES6中引入的基本數(shù)據(jù)類型灯萍，可以用作對象屬性的標識符轧铁。描述屬性是只讀的，可用于獲取符號對象的描述旦棉，更好了解它的作用齿风。

const symbol = Symbol('666我是描述');
symbol;
// Symbol(666我是描述)
Symbol.description;
// '666我是描述'

6.JSON Superset 超集
之前如果JSON字符串中包含有行分隔符(\u2028) 和段落分隔符(\u2029)药薯，那么在解析過程中會報錯。

JSON.parse('"\u2028"');
// SyntaxError

現(xiàn)在ES2019對它們提供了支持救斑。

JSON.parse('"\u2028"');
// ''

7.JSON.stringify() 加強格式轉(zhuǎn)化

'??'.length;
// 2

JavaScript將emoji解釋為兩個字符的原因是UTF-16將emojis（以及其他不尋常的字符）表示為兩個代理項的組合童本。我們的emoji用字符'\uD83D'和'\uDE0E'編碼。但是如果試圖單獨編寫這樣一個字符脸候，例如'\uD83D'穷娱，則會認為這是一個無效的文本字符串。在早期版本中运沦，這些字符將替換為特殊字符：

JSON.stringify('\uD83D');
// '"?"'

現(xiàn)在在字符代碼之前插入轉(zhuǎn)義字符泵额，結(jié)果仍是可讀且有效的UTF-8/UTF-16代碼：

JSON.stringify('\uD83D');
// '"\\ud83d"'

8.Array.prototype.sort() 更加穩(wěn)定
V8 之前的實現(xiàn)對包含10個以上項的數(shù)組使用了一種不穩(wěn)定的快速排序算法。

一個穩(wěn)定的排序算法是當兩個鍵值相等的對象在排序后的輸出中出現(xiàn)的順序與在未排序的輸入中出現(xiàn)的順序相同時携添。

ES10 提供了一個穩(wěn)定的數(shù)組排序:

var fruit = [
    { name: "Apple",      count: 13, },
    { name: "Pear",       count: 12, },
    { name: "Banana",     count: 12, },
    { name: "Strawberry", count: 11, },
    { name: "Cherry",     count: 11, },
    { name: "Blackberry", count: 10, },
    { name: "Pineapple",  count: 10, }
];
// 創(chuàng)建排序函數(shù):
let my_sort = (a, b) => a.count - b.count;
// 執(zhí)行穩(wěn)定的ES10排序:
let sorted = fruit.sort(my_sort);
console.log(sorted);

**9.Function.prototype.toString() **
函數(shù)是對象嫁盲，并且每個對象都有一個 .toString() 方法，因為它最初存在于Object.prototype.toString() 上烈掠。 所有對象（包括函數(shù)）都是通過基于原型的類繼承從它繼承的羞秤。

這意味著我們以前已經(jīng)有 funcion.toString()方法了。

從ES2019開始左敌，Function.prototype.toString()將從頭到尾返回源代碼中的實際文本片段锥腻。這意味著還將返回注釋、空格和語法詳細信息母谎。

function /* a comment */ foo() {}

之前，Function.prototype.toString()只會返回了函數(shù)的主體京革，但沒有注釋和空格奇唤。

foo.toString();
// 'function foo() {}'

但現(xiàn)在，函數(shù)返回的結(jié)果與編寫的一致匹摇。

foo.toString();
// 'function /* a comment  */ foo () {}'

ES11

1.String.prototype.matchAll
String.prototype的match() 方法僅返回完整的匹配結(jié)果咬扇，卻不會返回特定正則表達式組（Regex groups）的信息

const text = "From 2019.01.29 to 2019.01.30";
const regexp = /(?<year>\d{4}).(?<month>\d{2}).(?<day>\d{2})/gu;
const results = text.match(regexp);
console.log(results);
// [ '2019.01.29', '2019.01.30' ]

matchAll（）為所有匹配的匹配對象返回一個迭代器

const raw_arr = 'test1  test2  test3'.matchAll((/t(e)(st(\d?))/g));
const arr = [...raw_arr];

image.png

2.import()
ECMAScript 2015 引入了靜態(tài)模塊
ES2020提案引入import()函數(shù)，支持動態(tài)加載模塊

import()函數(shù)返回一個Promise對象廊勃，加載模塊成功以后懈贺，這個模塊會作為一個對象，當作then回調(diào)的參數(shù)坡垫。因此梭灿，可以使用對象解構(gòu)賦值的語法，獲取輸出接口冰悠。

import(`./home.js`)  // home.js中export const export1 = ''; ....
  .then(({export1, export2})=> 
    // 加載成功的回調(diào)
  })
  .catch(err => {
    // 加載失敗的回調(diào)
  });

import()是運行時執(zhí)行堡妒，也就是說，什么時候運行到這一句溉卓，就會加載指定的模塊皮迟。另外搬泥，import()函數(shù)與所加載的模塊沒有靜態(tài)連接關(guān)系，這點也是與import語句不相同伏尼。import()類似于Node的require方法忿檩，區(qū)別主要是前者是異步加載，后者是同步加載爆阶。

3. BigInt – 任意精度整數(shù)
JavaScript 所有數(shù)字都保存成 64 位浮點數(shù)燥透，這給數(shù)值的表示帶來了兩大限制。

1. 數(shù)值的精度：只能到 53 個二進制位（相當于 16 個十進制位）扰她，大于這個范圍的整數(shù)妙啃，JavaScript 是無法精確表示的。
2. 大于或等于2的1024次方的數(shù)值卷仑，JavaScript 無法表示于游，會返回Infinity。

為了更精確地表示沒有位數(shù)限制的整數(shù)忧勿，ES2020引入了不同于Number數(shù)字類型的BigInt數(shù)字類型杉女， 只用來表示整數(shù)（大整數(shù)），沒有位數(shù)的限制鸳吸，任何位數(shù)的整數(shù)都可以精確表示熏挎。為了與 Number 類型區(qū)別，BigInt 類型的數(shù)據(jù)必須添加后綴n晌砾。

const a = 2172141653n;
const b = 15346349309n;

// BigInt 可以保持精度
a * b // 33334444555566667777n

// 普通整數(shù)無法保持精度
Number(a) * Number(b) // 33334444555566670000

4.Promise.allSettled
用在處理所有的 promise 都 settled 的情況坎拐，無論結(jié)果是 fulfilled 還是 rejected. 你看 ，無需 catch!

Promise.allSettled([
  fetch("https://api.github.com/users/pawelgrzybek").then(data => data.json()),
  fetch("https://api.github.com/users/danjordan").then(data => data.json())
])
  .then(result => console.log(`All profile settled`));

5. globalThis
種在不同環(huán)境中獲取頂層對象的通用方式

• 瀏覽器里面养匈，頂層對象是window哼勇，但 Node 和 Web Worker 沒有window。
• 瀏覽器和 Web Worker 里面呕乎，self也指向頂層對象积担，但是 Node 沒有self。
• Node 里面猬仁，頂層對象是global帝璧，但其他環(huán)境都不支持

6.可選鏈（Optional chaining）
?.用戶檢測不確定的中間節(jié)點（對于對象屬性的長鏈式訪問易出錯又不易讀）， TypeScript 3.7 版本早已實現(xiàn)了此功能

// 之前
const title = data && data.article && data.article.title
// 之后
const title = data?.article?.title

7.空值合并運算符
與 || 相比湿刽，空值合并運算符 ?? 只會在左邊的值嚴格等于 null 或 undefined 時起作用的烁。

let user = {
    u1: 0,
    u2: false,
    u3: null,
    u4: undefined
    u5: '',
}
let u2 = user.u2 ?? '用戶2'  // false
let u3 = user.u3 ?? '用戶3'  // 用戶3
let u4 = user.u4 ?? '用戶4'  // 用戶4
let u5 = user.u5 ?? '用戶5'  // ''

8.export * as ns from “mod”
這是對 ES 規(guī)范的有力補充，它允許開發(fā)者以新名稱導出另一模塊的命名空間外部對象诈闺。

export * as ns from "mod"

ES12

1.replaceAll
replaceAll則是返回一個全新的字符串撮躁，所有符合匹配規(guī)則的字符都將被替換掉，替換規(guī)則可以是字符串或者正則表達式。

let string = 'I like 前端,I like 前端公蝦米'

//使用replace
let replaceStr = string.replace('like','love')
console.log(replaceStr)  // 'I love 前端,I like前端公蝦米'

//replace使用正則匹配所有
console.log(string.replace(/like/g,'love')) // 'I love 前端,I love 前端公蝦米'

//使用replaceAll
let replaceAllStr = string.replaceAll('like','love')
console.log(replaceAllStr) // 'I love 前端,I love 前端公蝦米'

需要注意的是把曼，replaceAll在使用正則表達式的時候杨帽，如果非全局匹配（/g），則replaceAll()會拋出一個異常

let string = 'I like 前端,I like 前端公蝦米'
console.log(string.replaceAll(/like/,'love')) //TypeError

2.Promise.any
當Promise列表中的任意一個promise成功resolve則返回第一個resolve的結(jié)果狀態(tài)
如果所有的promise均reject嗤军，則拋出異常表示所有請求失敗

Promise.any([
  new Promise((resolve, reject) => setTimeout(reject, 500, '哎呀注盈，我被拒絕了')),
  new Promise((resolve, reject) => setTimeout(resolve, 1000, '哎呀，她接受我了')),
  new Promise((resolve, reject) => setTimeout(resolve, 2000, '哎呀叙赚，她也接受我了')),
])
.then(value => console.log(`輸出結(jié)果: ${value}`))
.catch (err => console.log(err))


//輸出
//輸出結(jié)果:哎呀老客，她接受我了

Promise.any([
  Promise.reject('Error 1'),
  Promise.reject('Error 2'),
  Promise.reject('Error 3')
])
.then(value => console.log(`請求結(jié)果: ${value}`))
.catch (err => console.log(err))

//輸出
AggregateError: All promises were rejected

Promise.any與Promise.race十分容易混淆，務必注意區(qū)分震叮，Promise.race 一旦某個promise觸發(fā)了resolve或者reject胧砰，就直接返回了該狀態(tài)結(jié)果，并不在乎其成功或者失敗

3. WeakRefs
使用WeakRefs的Class類創(chuàng)建對對象的弱引用(對對象的弱引用是指當該對象應該被GC回收時不會阻止GC的回收行為)

當我們通過（const苇瓣、let尉间、var）創(chuàng)建一個變量時，垃圾收集器GC將永遠不會從內(nèi)存中刪除該變量击罪，只要它的引用仍然存在可訪問哲嘲。WeakRef對象包含對對象的弱引用。對對象的弱引用是不會阻止垃圾收集器GC恢復該對象的引用媳禁，則GC可以在任何時候刪除它眠副。

WeakRefs在很多情況下都很有用，比如使用Map對象來實現(xiàn)具有很多需要大量內(nèi)存的鍵值緩存竣稽，在這種情況下最方便的就是盡快釋放鍵值對占用的內(nèi)存囱怕。

目前，可以通過WeakMap()或者WeakSet()來使用WeakRefs

4. 邏輯運算符和賦值表達式
邏輯運算符和賦值表達式毫别，新特性結(jié)合了邏輯運算符（&&娃弓，||，??）和賦值表達式而JavaScript已存在的
復合賦值運算符有：

操作運算符：+= -= *= /= %= **=
位操作運算符：&= ^= |=
按位運算符：<<= >>= >>>=
現(xiàn)有的的運算符拧烦，其工作方式都可以如此來理解

表達式：a op= b
等同于：a = a op b

邏輯運算符和其他的復合賦值運算符工作方式不同

表達式：a op= b
等同于：a = a op (a = b)

a ||= b
//等價于
a = a || (a = b)

a &&= b
//等價于
a = a && (a = b)

a ??= b
//等價于
a = a ?? (a = b)

為什么不再是跟以前的運算公式a = a op b一樣呢，而是采用a = a op (a = b)钝计。因為后者當且僅當a的值為false的時候才計算賦值恋博，只有在必要的時候才執(zhí)行分配，而前者的表達式總是執(zhí)行賦值操作

const pages = [
  {
    title:'主會場',
    path:'/'
  },
  {
    path:'/other'
  },
  ...
]
  
for (const page of pages){
    page.title ??= '默認標題'
}
console.table(pages)
//(index)  title            path
//0        "主會場"      "/"
//1        "默認標題"    "/other"

5. 數(shù)字分隔符

數(shù)字分隔符私恬，可以在數(shù)字之間創(chuàng)建可視化分隔符债沮，通過_下劃線來分割數(shù)字，使數(shù)字更具可讀性

const money = 1_000_000_000

//等價于
const money = 1000000000

const totalFee = 1000.12_34
//等價于
const totalFee = 1000.1234
//該新特性同樣支持在八進制數(shù)中使用
const number = 0o123_456
//等價于
const number = 0o123456

參考：
http://www.reibang.com/p/13c5d002478b
http://www.reibang.com/p/40bc10005e9e
http://www.reibang.com/p/cf6dd11e8781
https://www.cnblogs.com/sweeeper/p/14344073.html?ivk_sa=1024320u
https://juejin.cn/post/6844903622870827022
http://www.reibang.com/p/fc43865811d5
https://blog.csdn.net/cpongo1/article/details/89534172
http://www.reibang.com/p/3e59df36342a
https://blog.csdn.net/qq_36958916/article/details/109490941