ES6之后的发展,简要描述比较实用的，对自己有帮助的，具体感兴趣可以去查阅官方文档
ES7
数组的includes()
let arr = ['aaa', 'bbb', 'ccc', 'ddd', NaN]
if(arr.indexOf('aaa') !== -1) {
console.log('存在aaa元素~');
}
// 参数二: 从哪一个元素开始
console.log(arr.includes('ddd', 2)) // true
// 通过indexOf,不能判断NaN是否存在，可以使用 [].includes() 来判断NaN是否存在
console.log(arr.includes(NaN)) // true
指数运算符 **
console.log(Math.pow(2, 3)) // 8
// ES7 中可以使用 ** 代替
console.log(2 ** 3) // 8
ES8
async await
异步的终极解决方案，没啥好说的，大家都知道...
Object.values()
返回的数组的内容是传入的对象中 所有键的 值，跟对象的key方法刚好是相对的，因为对象内部的元素是以键值对的形式存在的，所以很好理解
let obj = { name: '王大', age: 28 }
// 获取对象所有的值 可以直接将对象value值转为数组
console.log(Object.values(obj));
//结果会输出 ['王大','28']
console.log(Object.values('123'))
// 可以看到字符串被拆分为数组 [ '1', '2', '3' ]
Object.entries()
此方法可以枚举对象的所有属性，语法为[...args],与使用for...in循环遍历相同
let obj = { name: '王大', age: 28 }
console.log(Object.entries(obj))
// 此时对象会被转为二维数组 [ [ 'name', '王大' ], [ 'age', 28 ] ]
for(const [key, value] of Object.entries(obj)) {
console.log(key ,value);
}
//打印结果为 (name 王大)，(age 28)，可以直接获取对象的键值对
padStart()和padEnd()
padStart() 方法用另一个[字符串]填充当前字符串（重复，如果需要的话），以便产生的字符串达到给定的长度。填充从当前字符串的开始（左侧）应用的。padEnd() 填充从当前字符串的末尾（右侧）应用的。以此来达到补全目的
let str = '7282' let padStart = str.padStart(11, '*')
console.log(padStr) // *******7282
let str = '18896' let padEnd = str.padEnd(11, '*')
console.log(padEnd) // 18896******
ES9
Promise.prototype.finally()
它用于在Promise被解决（resolved）或拒绝（rejected）后，无论结果如何，都会执行指定的回调函数。
const promise = new Promise((resolve, reject) => {
// 一些异步操作
});
promise
.then(result => {
// 处理成功的情况
})
.catch(error => {
// 处理错误的情况
})
.finally(() => {
// 无论如何都会执行的操作
});
Rest/Spread
它允许在对象字面量中使用剩余运算符（...）来获取对象的剩余属性，或者使用扩展运算符（...）将对象的属性展开,在日常工作中使用比较多的
const { x, y, ...rest } = { x: 1, y: 2, z: 3, w: 4 };
console.log(x); // 1
console.log(y); // 2
console.log(rest); // { z: 3, w: 4 }
const obj1 = { x: 1, y: 2 };
const obj2 = { ...obj1, z: 3 };
console.log(obj2); // { x: 1, y: 2, z: 3 }
正则表达式命名捕获组
在正则表达式中，可以使用命名捕获组来给捕获的子字符串命名。
const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = regex.exec('2023-7-18');
console.log(match.groups.year); // 2023
console.log(match.groups.month); // 07
console.log(match.groups.day); // 18
ES10
数组的flat和flatMap扁平化
这两个方法为数组增加了扁平化和映射的功能。Array.prototype.flat()方法可将嵌套数组扁平化为一维数组，而Array.prototype.flatMap()方法在映射后的结果上直接执行扁平化。
// 1.flat对数组进行降维(扁平化处理)
const num = [5, 10, [15, [20, 25, 30], 35], [40, 45], 50, 55]
const newNum = num.flat()
// 深度默认值为1 (depth?: 1)
console.log(newNums); //得出 [5, 10, 15, Array(3), 35, 40, 45, 50, 55]]
const newNum = num.flat(Infinity)
console.log(newNums); //得出 [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55]
// 2.flatMap的使用 映射函数先映射每个元素,将其压缩为一个新数组
// 执行步骤> 先进行数组的map操作,在做flat操作, flatMap的深度为 1
const arrs = [1, [2, 3], 4, [5, [6, 7, 8], 9], 10]
const newArrs = arrs.flatMap(item => { return item })
console.log(newArrs); //得出 [1, 2, 3, 4, 5, Array(3), 9, 10]
String.trimStart()和String.trimEnd()
主要是去除字符串首尾空白字符
let str = ' Hello World ' console.log(str.length) // 17
let trimS = str.trimStart()
console.log(trimS.length); // 13
let trimE = str.trimEnd()
console.log(trimE.length); //14
Object.fromEntries()
返回一个给定对象自身可枚举属性的键值对数组
通过 Object.fromEntries， 可以将 Map 转化为 Object:
const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
console.log(Object.fromEntries(map)); // { foo: "bar", baz: 42 }
ES11
空值合并运算？？
// 空值合并运算 ??
const foo = 0
// const bar = foo || 'default'
// || (对0和空字符串失效),foo = 0时,bar = 'default'
// ES11 提供 ?? 运算符 (对0和空字符串进行处理)
const bar = foo ?? 'default'
// 是undefined/null时,使用后面的默认值
console.log(bar)
可选链
进行null/undefined判断时更加清晰和简洁
const obj = { name: '王大',
// friend: {
// name: 'wr',
// girlFriend: {
// name: 'zrm'
// }
// }
}
console.log(obj.friend?.girlFriend?.name) // friend? 判断friend有没有,没有返回undefined
ES12
数字分隔符
数字分隔符允许你在文字数字的数字之间添加下划线，这使它们更具可读性。当文件被解析时，这些下划线将被自动去除
let num1 = 1_000_000;
console.log(num1); // 1000000
let num2 = 1_000_000.1314
console.log(num2); // 1000000.1314
replaceAll
返回一个全新的字符串，所有符合匹配规则的字符都将被替换掉
const str = 'hello world';
str.replaceAll('l', ''); // "heo word"`
WeakRefs
使用WeakRefs的Class类创建对对象的弱引用(对对象的弱引用是指当该对象应该被GC回收时不会阻止GC的回收行为)
逻辑赋值运算
逻辑运算符和赋值表达式，新特性结合了逻辑运算符（&&，||，??）和赋值表达式而JavaScript已存在的 复合赋值运算符有：
a ||= b 等价于 a = a || (a = b)
a &&= b 等价于 a = a && (a = b)
a ??= b 等价于 a = a ?? (a = b)`
// !! 将其他类型转为Boolean
console.log(!!123); // true 等价于 console.log(Boolean(123))
Promise.any
Promise.any() 接收一个Promise可迭代对象，只要其中的一个 promise 成功，就返回那个已经成功的 promise 。如果可迭代对象中没有一个 promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 promise
const promise1 = new Promise((resolve, reject) => reject('我是失败的Promise_1'));
const promise2 = new Promise((resolve, reject) => reject('我是失败的Promise_2'));
const promiseList = [promise1, promise2];
Promise.any(promiseList)
.then(values=>{
console.log(values);
})
.catch(e=>{
console.log(e);
});
