ES6/ES7笔记

[linchwei]

1. let，不存在变量提升；
2. let,，存在TDZ，即在代码块内，变量声明前都不可用；
3. 因为TDZ存在，typeof操作符不在是百分百安全的操作符;
4. let，在相同作用域内不能重复声明；

[linchwei]

1. const，声明只读常量，值不能改变；
2. const，不能重复声明；
3. const，并不是值不得改动，而是指向的那个内存地址不得改动；

[linchwei]

定义：按照一定模式，从数组和对象中提取值，对变量进行赋值，成为解构。

数组解构

// es5
let a = 1;
let b = 2;
let c = 3;

// es6
let [a, b, c] = [1, 2, 3]

本质上， 属于“模式匹配”，只要等号两边模式相同，左边的变量就会被赋予对应的值。

let [a, [[a], c], d] = [1, [[2], 3], 4]
a  // 1
b // 2
c  // 3
d // 4

解构不成功，值就等于undefined，即左值找不到右值

let [a] = []
let [b, c] = [1]
a // undefined
b // 1
c // 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

[linchwei]

右值不是可遍历的解构，报错

// 报错
let [levy] = 1;
let [levy] = false;
let [levy] = NaN;
let [levy] = undefined;
let [levy]  null;
let [levy] = {};

Set结构也可以使用数字解构

let [x, y, z] = new Set(['a', 'b', 'c'])

[linchwei]

解构赋值允许默认值

let [levy = true] = []
levy   // true

let [x, y = 'love'] = ['a'];
x   // 'a'
y   // 'love'
let [x, y = 'b'] = ['a', undefined]
x   //  'a'
y   //  'b'

解构使用"==="，判断是否有值，所以只有严格等于undefined，默认值才会生效

let [x = 1] = [undefined]
x  // 1

let [x = 1] = [null]
x  // null

默认值可以引用解构赋值的其他位置，前提已经声明

let [x = 1, y = x] = [];
x   // 1
y   // 1

let [x = 1, y = x] = [2]
x   // 2
y   // 2

let [x= 1, y = x] = [1, 2]
x   // 1
y   // 2

let [x= y, y = 1] = []
// ReferenceErrot: y is not defined

[linchwei]

对象解构

let { foo, bar } = { foo: 'aaa', bar: 'bbb' }
foo   // 'aaa'
bar   // 'bbb'

let { baz } = { foo: 'aaa', bar: 'bbb' }
baz   // undefined 

对象解构的本质是先找到同名属性，然后在赋值给对应的变量

let { foo, baz } = { foo: 'aaa', bar: 'bbb' }
baz   // 'aaa'

let obj = { first: 'hello', last: 'world' }
let { first: f, last: 1 } = obj
f   // 'hellow'
l   // 'world'