一、ES8知识点

1.Object.values

之前我们可以通过Object.keys()获取对象的所有的key。

在ES8中提供了Object.values()获取对象的所有的value值。

• 如果传入的是一个数组，则是将这个数组本身返回
• 如果传入的是字符串，是将字符串中的所有字符放入到一个数组中

const obj={
  name:"wjy",
  age:18
}
const keys=Object.keys(obj);
const values=Object.values(obj);
console.log(keys,values);

console.log(Object.values([1,2,3,4]));//如果传入的是一个数组，则返回的是数组本身
console.log(Object.values("abc"));//如果传入的是一个字符串，   将字符串中所有的字符放入到一个数组中，[ 'a', 'b', 'c' ]

2.Object.entries

通过Object.entries可以获取到一个数组，数组中会存放可枚举属性的键值对数组。([[],[]])

• 如果传入的是一个数组，则对应的索引为key，对应的值为value
• 如果传入的是一个字符串，则对应的索引为key，value为对应的单个字符

// * 可获取到一个数组，数组存放的是可枚举属性的键值对数组
const obj={
  name:"wjy",
  age:20,
}
console.log(Object.entries(obj));//[ [ 'name', 'wjy' ], [ 'age', 20 ] ]

const entries=Object.entries(obj);
entries.forEach((item)=>{
  console.log(item[0],":",item[1]);
})

// * 还可以传入一个数组，会将索引值作为key，对应的值作为value
console.log(Object.entries(["wjy","hyz","tl"]));//[ [ '0', 'wjy' ], [ '1', 'hyz' ], [ '2', 'tl' ] ]

// * 如果传入一个字符串，会将索引值作为key，value为对应的字符串
console.log(Object.entries("abc"));//[ [ '0', 'a' ], [ '1', 'b' ], [ '2', 'c' ] ]

3.String Padding

某些字符串外面需要对其进行前后的填充，来实现某种格式化效果，ES8中增加了padStart何padEnd方法，，分别是对字符串的首尾进行填充的。

• 两个参数
  • 要填充到什么长度
  • 使用什么字符填充
    • 如果不传，则默认以空格填充

const message="Hello World";

const newMessage=message.padStart(15,"*").padStart(20,0)
console.log(newMessage); 

// * 案例
const cardNumber="113334789527057429";
// * 后四位前面全是*
const lastFourNum=cardNumber.slice(-4);
const finalCard=lastFourNum.padStart(cardNumber.length,"*")
console.log(finalCard);//**************7429

4. Trailing Commas

允许在函数定义和调用时多加一个逗号

// * 允许在函数定义和调用时多加一个逗号
function sum(a,b,){
  return a+b;
}

console.log(sum(1,2,));

5. Object Descriptors

• Object.getOwnPropertyDescriptors()：获取一个对象的所有属性描述符
• function的async和await

// * 获取一个对象的所有属性描述符
const obj={
  name:"wjy",
  age:20
}

console.log(Object.getOwnPropertyDescriptors(obj));
// {
//   name: {
//     value: 'wjy',
//     writable: true,
//     enumerable: true,
//     configurable: true
//   },
//   age: { value: 20, writable: true, enumerable: true, configurable: true }
// }

二、ES9新增知识点

• Async iterators
• Object spread operators：展开运算符
• Promise finally

三、ES10新增知识点

1. flat、flatMap

flat()方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中元素合并为一个新数组返回。

flatMap()方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。

• 注意一：flatMap是先进行map操作，再做flat的操作
• 注意二：flatMap中的flat相当于深度为1

// * flat的使用
const nums=[10,20,[2,9],[[30,40],[10,45]],78,[55,88]];
const newNum=nums.flat(1);
console.log(newNum);//[ 10, 20, 2, 9, [ 30, 40 ], [ 10, 45 ], 78, 55, 88 ]
const newNum2=nums.flat(2);
console.log(newNum2);
// [
//   10, 20,  2,  9, 30,
//   40, 10, 45, 78, 55,
//   88
// ]

// * flatMap 
const nums2=[10,20,30];
const newNums2=nums2.flatMap((item)=>item*2);
console.log(newNums2);

// * flatMap的应用场景

const messages=["hello world","你好啊 李银河","my name is coderwhy"];
const words=messages.flatMap((item)=>item.split(" "))
console.log(words);
// [
//   'hello',  'world',
//   '你好啊', '李银河',
//   'my',     'name',
//   'is',     'coderwhy'
// ]

2. Object fromEntries

在前面，我们可以通过Object.entries将一个对象转换成entries，那么如果我们有一个entries，如何将其转换成对象呢？

ES10提供了Object.fromEntries来完成转换。

const obj={
  name:"wjy",
  age:20,
  height:1.6
}
const objEntries=Object.entries(obj);
// 怎么将Entries转化为之前的对象呢
// *ES10之前的用法
const newObj={};
objEntries.forEach((item)=>{
  newObj[item[0]]=item[1];
})
console.log("newObj:",newObj);
// * ES10
const objEntriesToObj=Object.fromEntries(objEntries);
console.log(objEntriesToObj);

// * for...in 拿的到是数组的索引值

2.1 应用场景

const queryString="name=wjy&age=18&height=1.88";
const queryParams=new URLSearchParams(queryString);
console.log(queryParams);//* URLSearchParams { 'name' => 'wjy', 'age' => '18', 'height' => '1.88' }
for(const item of queryParams){
  console.log(item);//[ 'name', 'wjy' ]
}
const objParams=Object.fromEntries(queryParams);
console.log(objParams);//{ name: 'wjy', age: '18', height: '1.88' }

3.trimStart、trimEnd

trimStart:去除头部空格

trimEnd:去除尾部空格

const message="    Hello World    ";
//trim是ES10之前的 去除首尾空格
// trimStart:去除头部空格
// trimEnd；去除尾部空格

console.log(message.trim());//* Hello World 
console.log(message.trimStart());//Hello World    
console.log(message.trimEnd());//    Hello World

4.Symbol description和Optional catch binding

• Symbol description
• Optional catch bingding

四、ES11

1.BigInt

在早期的Javascript中，我们不能正确的表示过大的数字：

• 大于MAX_SAFE_INTEGER的数值，表示的可能是不正确的。

如何表示一个大数呢？

• 在数值后面加一个n

• 如果一个大数与一个小数相加会报错，需要将小数也表示与大数，才能正确进行运算

  • 一种是直接在后面加个
  • 第二种是使用 类型转换 BigInt(num)

• 如果将一个大数转化为小数，可能是不正确的，不安全的。

// * 在早期的js中，我们不能正确的表示过大的数字
// * 大于MAX_SAFE_INTEGER的数值，表示的可能是不正确的

// ES11之前 最大的数字
const maxInt=Number.MAX_SAFE_INTEGER;//9007199254740991
console.log(maxInt);
console.log(maxInt+1);//9007199254740992
console.log(maxInt+2);//9007199254740992

//*  ES11 在数值后加个n
const bigInt=900719925474099100n;
// console.log(bigInt+100);//* 报错

console.log(bigInt+100n);//900719925474099200n

console.log(bigInt+BigInt(100));//900719925474099200n

const smallNum=Number(bigInt);//不一定是正确的
console.log(smallNum);

2. Nullish Coalescing Operator（空值合并运算）

Nullish Coalescing Operator:空值合并运算 ??

• ??：只要前面是null或者undefined才会取后面的值
  • 有点类似 逻辑或，但比逻辑或更严谨

// * 空值合并运算 ??

let foo;
// const bar=foo|| "default value" ;//* 逻辑或:有缺陷：0 空字符串  false 最后都会取默认值

const bar=foo??"default value";//这个只有当foo的值是null或者undefined，才会去后面运算

console.log(bar);

3. Optional Chaining(可选链)

主要作用是让我们的代码在进行null或undefined判断时更加清晰和简洁，可以避免有些错误

语法:

?.

const info={
  name:"wjy",
  friend:{
    name:"LiLei",
    girlFriend:{
      name:"hmm"
    }
  }
}

// 想要获取info.friend.girlFriend.name的值
// console.log(info.friend.girlFriend.name);

// * 在前端获取数据时，如果数据还未从后端获取到，再使用undefined.操作时就会报错

if(info&&info.friend&&info.friend.girlFriend){//* 所以需要这样进行判断，但是这样写似乎太长了，代码可读性差
  console.log(info.friend.girlFriend.name);
}

// * ES11提供了可选链 Optional
console.log(info.friend?.girlFriend?.name);

4.Global this

在之前我们希望获取JavaScript环境的全局对象，不同的环境获取的方式是不一样的。

• 比如在浏览器获取全局对象是this、window
• 比如在Node中我们需要通过global来获取

在ES11中,使用globalThis来获取全局对象，在不同环境中，指向不同的全局对象。

// * 获取某个环境的全局对象

// * 在浏览器中
// console.log(this);
// console.log(window);


// * Node环境下
// console.log(global);


// * 在不同环境下，显示不同的全局对象 globalThis
console.log(globalThis);

5.for...in标准化

在ES11之前，虽然有很多浏览器支持for...in来遍历对象类型，但是并没有被ECMA标准化。

在ES11中，对其进行了标准化，for...in是用于遍历对象的key

const obj={
  name:"wjy",
  age:20,
  height:1.88
}

for(const item in obj){
  console.log(item);
}

6.其他知识

• Dynamic Import ：动态导入
• Promise.allSettled
• import meta

五、ES12

1. FinalizationRegistry

FinalizationRegistry对象可以让你在对象被垃圾回收时请求一个回调。

• FinalizationRegistry提供了这样的一种方法：在一个在注册表中注册的对象被回收时，请求在某个时间点上调用一个清理回调。（清理回调有时被称为finalizer）
• 你可以通过调用register方法，注册任何你想要清理回调的对象，传入该对象和所含的值。

以下代码建议在浏览中运行，会看到效果的。

// * FinalizationRegistry是一个类型
const finalRegistry=new FinalizationRegistry((value)=>{
  console.log("注册在finalRegistry的某个对象被销毁了",value);
});
let obj={
  name:"why"
}
let info={
  age:18
}
finalRegistry.register(obj,"obj");
finalRegistry.register(info,"info");
obj=null;//* GC不定时来检查内存中是否有要销毁的对象
info=null;

强引用

// * FinalizationRegistry是一个类型
const finalRegistry=new FinalizationRegistry((value)=>{
  console.log("注册在finalRegistry的某个对象被销毁了",value);
});
let obj={
  name:"why"
}
let info=obj;
finalRegistry.register(obj,"obj");
obj=null;//* 即使obj指向null，但是obj原来指向的那片内存空间由info指向的，所以并不会被销毁

弱引用

// * FinalizationRegistry是一个类型
const finalRegistry=new FinalizationRegistry((value)=>{
  console.log("注册在finalRegistry的某个对象被销毁了",value);
});
let obj={
  name:"why"
}
let info=new WeakSet();
info.add(obj)
finalRegistry.register(obj,"obj");
obj=null;//* 因为obj指向null，但是obj原来指向的那片内存空间由info指向的（弱引用），所以GC最后会将obj对应的内存空间销毁的

2.WeakRef

如果我们默认将一个对象赋值给另外一个引用时，那么这个引用是一个强引用。

• 如果我们希望是一个弱引用的话，可以使用WeakRef
• deref()可以获取那个引用

// * FinalizationRegistry是一个类型
const finalRegistry=new FinalizationRegistry((value)=>{
  console.log("注册在finalRegistry的某个对象被销毁了",value);
});
let obj={
  name:"wjy"
}
// let info=obj;
// let info=new WeakSet();
// info.add(obj)
let info=new WeakRef(obj);
console.log(info.deref().name);//why
finalRegistry.register(obj,"obj");
obj=null;//* 因为obj指向null，但是obj原来指向的那片内存空间由info指向的（弱引用），所以GC最后会将obj对应的内存空间销毁的
setTimeout(()=>{
  // * info.deref() 如果被销毁了，则为undefined
  console.log(info.deref()&&info.deref().name);
},10*1000)

3.Logical Assignment Operators

• ||=
• &&=
• ??=

// * || 逻辑或
let message="";
// message=message||"default value";
// * ||=
message||="default value";
console.log(message);
// * && 逻辑与


// const obj={
//   name:"wjy",
//   foo:function(){
//     console.log("foo函数被调用了");
//   }
// }
// obj.foo&&obj.foo()


// * &&=
let info={
  name:"wjy"
}
// * 首先判断info是否有值，取出info.name
// info=info&&info.name;
info&&=info.name
console.log(info);//wjy
// * ?? 逻辑空运算

let message2="";
message2=message2??="default value";
console.log(message2);

4. 其他知识点

• Numeric Separator(数字分割)：123_450_330
• String.replaceAll：字符串替换

六、总结

ES8-ES12的相关知识点.png