ES2020新特性（简称：ES11)

一：promise

传统的promise.all:所有的promise均为成功，才可以走入then的回掉（参数为数组），只要有一个失败，则走入catch的回掉

举个例子

const promises = [
 Promise.resolve(1),
 Promise.resolve(2),
 Promise.reject('error')
];
 
 
Promise.all(promises)
 .then(responses => console.log(responses))
 .catch(e => console.log(e)) 
// 结果为"error"



const promises = [
 Promise.resolve(1),
 Promise.resolve(2),
];
 
 
Promise.all(promises)
 .then(responses => console.log(responses))
 .catch(e => console.log(e)) 
// 结果为[1,2]

1.promise.any:有多个异步计算，同时仅仅用第一个计算最快且成功的。

const promises = [
 Promise.resolve(1),
 Promise.resolve(2),
];
 
 
Promise.any(promises)
 .then(responses => console.log(responses))
 .catch(e => console.log(e))
// 结果为1

2.Promise.allSettled:全部进入then的回掉，并且可以拿到每个Promise的状态, 而不管是否成功还是失败

Promise.allSettled([
  Promise.reject({ code: 500, msg: '服务异常' }),
  Promise.resolve({ code: 200, list: [] }),
  Promise.resolve({ code: 200, list: [] })
]).then(res => {
  console.log(res)
})
//[
    {
        "status": "rejected",
        "reason": {
            "code": 500,
            "msg": "服务异常"
        }
    },
    {
        "status": "fulfilled",
        "value": {
            "code": 200,
            "list": []
        }
    },
    {
        "status": "fulfilled",
        "value": {
            "code": 200,
            "list": []
        }
    }
]

二：运算符

1.??：判断运算符，左侧是否为null或undefined时，才会返回右侧的值，类似||

'' ?? 1 // ''
'' || 1 // 1
0 ?? 1  // 0
0 || 1  // 1
null ?? 1 // 1
null || 1 // 1
undefined ?? 1 // 1
undefined || 1 // 1

2.?.链式判断运算符,一般代码用来处理类似(res&&res.data&&res.data.id)

可简化为：res?.data?.id

如果res或res.id是null/undefined，表达式将会短路计算直接返回undefined。

三.import()

动态导入：

import('/modules/my-module.js')
  .then((module) => {
    // 动态导入，并在导入成功后做一些操作
  });

支持await:

let module = await import('/modules/my-module.js');
//import(module) 函数可以在任何地方调用。它返回一个解析为模块对象的 promise。

四.BigInt()：可以大数计算，防止丢失精度

const aNumber = 111;
const aBigInt = BigInt(aNumber)
console.log(aBigInt)
// 111n

只要在数字末尾加上 n，就可以正确计算大数

2n*8n=16n

但是不能将 BigInt与Number混合使用。比较Number和 BigInt是可以的，但是不能把它们相互运算