ES6笔记-语法拓展

ES6变量方面的拓展

1 let和const命令

let声明的变量不会发生变量提升

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;

// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

1.1 暂时性死区

var tmp = 123;

if (true) {
  tmp = 'abc'; // ReferenceError
  let tmp;
}

在if{}作用域内，对tmp在声明前赋值会报错
这意味着typeof不在是一个百分之百安全的操作，在let变量声明前使用typeof就会抛出ReferenceError

作为比较，如果一个变量根本没有被声明，使用typeof反而不会报错。

typeof undeclared_variable // "undefined"

有些死区太隐蔽不容易发现

function bar(x = 2, y = x) {
  return [x, y];
}
bar(); // [2, 2]

// 不报错
var x = x;

// 报错
let x = x;
// ReferenceError: x is not defined

2 块级作用域与函数声明

// 浏览器的 ES6 环境
function f() { console.log('I am outside!'); }

(function () {
  if (false) {
    // 重复声明一次函数f
    function f() { console.log('I am inside!'); }
  }

  f();
}());
// Uncaught TypeError: f is not a function

ES5会输出 I am inside
ES6会报错
-允许在块级作用域内声明函数。
-函数声明类似于var，即会提升到全局作用域或函数作用域的头部。
-同时，函数声明还会提升到所在的块级作用域的头部。
注意，上面三条规则只对 ES6 的浏览器实现有效，其他环境的实现不用遵守，还是将块级作用域的函数声明当作let处理。

尽量避免在块级作用域声明函数，如果确实需要应该写成函数表达式

// 块级作用域内部的函数声明语句，建议不要使用
{
  let a = 'secret';
  function f() {
    return a;
  }
}

// 块级作用域内部，优先使用函数表达式
{
  let a = 'secret';
  let f = function () {
    return a;
  };
}

3 const

const除了指向的对象或数据不能改变外（指向的对象里的数据可以改变），其他性质与let相同
如果真想冻结对象，用Object.freeze（）方法

const foo = Object.freeze({});

// 常规模式时，下面一行不起作用；
// 严格模式时，该行会报错
foo.prop = 123;

除了将对象本身冻结，对象的属性也应该冻结。下面是一个将对象彻底冻结的函数。

var constratize = (obj) => {
	Object.freeze(obj);
	Object.keys(obj).forEach((key,i)=>{
		if(typeof obj[key] === 'object'){
			constratize(obj[key]);
		}
	});
}

4 变量的解构赋值

4.1数组的解析赋值

let [a, b, c] = [1, 2, 3];

let [foo, [[bar], baz]] = [1, [[2], 3]];
foo // 1
bar // 2
baz // 3

let [ , , third] = ["foo", "bar", "baz"];
third // "baz"

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

let [head, ...tail] = [1, 2, 3, 4];
head // 1
tail // [2, 3, 4]

let [x, y, ...z] = ['a'];
x // "a"
y // undefined
z // []

如果解构不成功，变量的值就等于undefined。
允许指定默认值

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

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

注意，ES6 内部使用严格相等运算符（===），判断一个位置是否有值。所以，只有当一个数组成员严格等于undefined，默认值才会生效。

4.2 对象的解析赋值

对象的解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定；而对象的属性没有次序，顺序不影响取值，变量必须与属性同名，才能取到正确的值。
解构失败，undefined

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

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

把现有对象赋值到某个变量

// 例一
let { log, sin, cos } = Math;

// 例二
const { log } = console;
log('hello') // hello

对象嵌套解构

let obj = {
  p: [
    'Hello',
    { y: 'World' }
  ]
};

let { p, p: [x, { y }] } = obj;
x // "Hello"
y // "World"
p // ["Hello", {y: "World"}]

const node = {
  loc: {
    start: {
      line: 1,
      column: 5
    }
  }
};

let { loc, loc: { start }, loc: { start: { line }} } = node;
line // 1
loc  // Object {start: Object}
start // Object {line: 1, column: 5}

上面代码有三次解构赋值，分别是对loc、start、line三个属性的解构赋值。注意，最后一次对line属性的解构赋值之中，只有line是变量，loc和start都是模式，不是变量。

对已经声明的变量进行解构

// 错误的写法
let x;
{x} = {x: 1};
// SyntaxError: syntax error

// 正确的写法
let x;
({x} = {x: 1});

上面代码的写法会报错，因为 JavaScript 引擎会将{x}理解成一个代码块，从而发生语法错误。只有不将大括号写在行首，避免 JavaScript 将其解释为代码块，才能解决这个问题。

4.3字符串的解构赋值

字符串也可以解构赋值。这是因为此时，字符串被转换成了一个类似数组的对象。

const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"
c // "l"
d // "l"
e // "o"

let {length : len} = 'hello';
len // 5

解构赋值的规则是，只要等号右边的值不是对象或数组，就先将其转为对象。由于undefined和null无法转为对象，所以对它们进行解构赋值，都会报错。

4.4 用途

1）交换变量的值

let x = 1;
let y = 2;

[x, y] = [y, x];```
2）从函数返回多个值

```javascript
// 返回一个数组

function f([x,y,z]){...}
f([1,2,3]);

// 返回一个对象

function example() {
	return{
		foo:1,
		bar:2
	};
}

3）函数参数的定义

//参数是一组有次序的值
function f([x,y,z]){...}
f([1,2,3]);

4）提取JSON数据
解构赋值对提取JSON对象中的数据，尤其有用。

let jsonData = {
	id:42,
	status:"OK",
	data:[867,5309]
};

let {id,status,data:number} = jsonData;

5)函数参数的默认值
这个不太懂
6）遍历Map结构
任何部署了Iterator接口的对象，都可以用for…of循环遍历

//对一个map的定义省略
for (let [key,value] of map){
	console.log(key+"is"+value);
}

如果只想获取键名，或者只想获取键值，可以写成下面这样。

for(let [key] of map){}
for(let [,value] of map){}

7）输入模块的指定方法

加载模块时，往往需要指定输入哪些方法。解构赋值使得输入语句非常清晰。

const { SourceMapConsumer, SourceNode } = require("source-map");

不太懂