es6-one

读了两遍阮一峰的es6的文档了，确实很经典，收获很多，做一下总结

let与const: 不存在变量提升,且存在暂时性死区，不允许重复声明
一般const用于声明常量,但是如果常量是对象的话，可以修改对象的属性，因为在内存中，对象的地址没有变化
let用于声明变量

console.log(numVar); // 输出undefined
var numVar = 2;
// let 的情况
console.log(numLet); // 报错ReferenceError
let numLet = 2;

const PI = {};
PI = 3;
//TypeError: Assignment to constant variable.

对数组和对象的解构赋值
数组：按照对应位置，对变量赋值,“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。

let a = 1;
let b = 2;
let c = 3;
//let [a, b, c] = [1, 2, 3];
let [foo, [[bar], baz]] = [1, [[2]]];//如果解构不成功，变量的值就等于undefined

let [x, y] = [1, 2, 3];
x // 1
y // 2
不完全解构

let [a, [b], d] = [1, [2, 3], 4];//不完全解构
a // 1
b // 2
d // 4

对于Set与Map结构，也可以使用数组的解构赋值，应该说，只要某种数据结构具有Iterator接口，都可以采用数组形式的解构赋值
解构赋值允许指定默认值，只有在严格等于undefined时，才会使用默认值

let [foo = true] = [];
// foo // true

对象的解构赋值，对对象的解构是按照属性名去解构的

let { name, age } = { name: '李华', age:18 };// name= '李华' age = 18
let {sex} = {bar: 'baz'};//解构失败，foo的值为undefined
let { foo: baz } = { foo: 'aaa', bar: 'bbb' };// baz = "aaa"

变量名与属性名不一致时，需要写成下面这样,其实就是取别名

let obj = { first: 'hello', last: 'world' };
let { first: fir, last: l } = obj;
// f = 'hello'
// l = 'world'

对象的解构赋值的内部机制，是先找到同名属性，然后再赋给对应的变量。真正被赋值的是后者，而不是前者

let { foo: Foo } = { foo: 'aaa' };
//baz = "aaa"
//Foo error: foo is not defined

嵌套赋值

let obj = {};
let arr = [];
({ foo: obj.prop, bar: arr[0] } = { foo: 123, bar: true });
// obj = {prop:123}
// arr = [true]

模板字符串 很好用,结构更明确

const name='李华'
const str=`我是${name}`
//原始拼接的方式
const yStr='我是'+name

函数的扩展:参数默认值

function Myfun (name='李华',age='18',{childName='lili'}={}){
console.log(name,age,childName)
console.log(arguments,'类数组')
}
Myfun(1,2,3,4,5,6,8)//李华 18 lili
Myfun('小明')//小明 18 lili


function MyfunTow (name='李华',age='18',{childName='lili'}={},...args){
console.log(name,age,childName)
console.log(args,'数组')
}
MyfunTow(1,2,3,4,5,6,8)//李华 18 lili

在es6中函数有剩余参数的属性，无论是箭头函数还是普通函数都拥有此属性且是数组，但是函数的arguments属性只有普通函数拥有，箭头函数是没有的，arguments是类数组，并不是真正的数组，类数组可以使用es6提供的数组的新方法from进行转化为真正的数组

es6新增的对象的方法Object.is()

Object.is() 与===的区别 react中使用的比较多,例如对于state的比较与useEffect的依赖项和useMemo，useCallback的依赖项都是使用的Object.is()来进行对比的，并不是使用的===或者深度比较

主要是为了处理NAN和+0，-0的问题

+0 === -0 //true
NaN === NaN // false

Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

运算符扩展，链判断运算符 这个用的比较多
编程实务中，如果读取对象内部的某个属性，往往需要判断一下，属性的上层对象是否存在。比如，读取message.body.user.firstName这个属性，安全的写法是写成下面这样。

const obj={
// children:{
// name:'李华'
// },
// name:'李华father'
}
console.log(obj.children?.name)//李华
console.log(obj.children.name)//报错
obj.say?.()//没有报错
obj.say()//报错

其实?.就相当于一种短路机制，如果?.前面的值为null或者undefined，那么就不会执行后面的代码，直接返回undefined

??运算符 NUll合并运算符 只有??前面的值为null或者undefined时，才会返回后面的值，否则返回前面的值
举个栗子

console.log(false ?? 'lili')//false
console.log(null ?? 'lili')//lili