ES6基础教程(整理自阮一峰)

------------------------
ECMAScript 6 简介
------------------------
ECMAScript 和 JavaScript 的关系是，前者是后者的规格，后者是前者的一种实现
另外 ECMAScript 方言还有 Jscript 和 ActionScript

ES6 = ES2015

查看node支持的es6特性:
$ node --v8-options | grep harmony

查看自己浏览器对es6的支持:
http://ruanyf.github.io/es-checker/

Babel / Traceur 转码器:
~

------------------------
let / const
------------------------
1. let用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效
{
let a = 10;
var b = 1;
}
a // ReferenceError: a is not defined.
b // 1

2. for循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域
for (let i = 0; i < 3; i++) {
let i = 'abc';
console.log(i);
}
// abc
// abc
// abc

3. let所声明的变量一定要在声明后使用, 否则报错
console.log(bar); // 报错ReferenceError
let bar = 2;

4. 暂时性死区: 跟上一种情况相似, 必须先声明后使用
var tmp = 123;
if (true) {
tmp = 'abc'; // ReferenceError
let tmp;
}

5.
var x = x;// 不报错
let x = x;// 报错

6. typeof不再安全: 所以使用变量之前记得要先声明
typeof x; // ReferenceError
let x;

7. 不允许重复声明
function func(arg) {
let arg; // 报错
}

8. 块级作用域不返回值, 怎么办: 加上do，使它变为do表达式
变量x会得到整个块级作用域的返回值（t * t + 1）
let x = do {
let t = f();
t * t + 1;
};

9. 与顶层对象脱钩
var a = 1;
window.a // 1

let b = 1;
window.b // undefined

10. const: 与let类似, 区别是一旦声明，常量的值就不能改变

------------------------
变量的解构赋值
------------------------
1. 解构: 按照一定模式，从数组和对象中提取值，对变量进行赋值
let [a, b, c] = [1, 2, 3];//完全解构成功
let [bar, foo] = [1];//部分解构不成功, foo的值是: undefined
let [a, [b], d] = [1, [2, 3], 4];//不完全解构, a 1, b 2, d 4

2. 如果等号的右边不是可遍历的结构，那将会报错
let [foo] = null; // 报错
let [foo] = {}; // 报错

3. set结构, 也可以赋值
let [x, y, z] = new Set(['a', 'b', 'c']);

4. 默认值
let [foo = true] = [];
foo // true

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

let [x = 1] = [null]; //x的值是null, 只能用undefined

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

5. 对象的解构赋值
5.1 变量必须与属性同名，才能取到正确的值
let { bar, foo } = { foo: "aaa", bar: "bbb" };
let { baz } = { foo: "aaa", bar: "bbb" }; //baz的值是undefined

5.2 如果变量名与属性名不一致: foo是匹配的模式，baz才是变量
let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
baz // "aaa"

5.3 还支持对象赋值, 嵌套赋值: ~

6. 字符串的解构赋值
const [a, b, c, d, e] = 'hello';
a // "h"
b // "e"

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

7. 数值和布尔值的解构赋值
let {toString: s} = 123;
s === Number.prototype.toString // true

let {toString: s} = true;
s === Boolean.prototype.toString // true

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

8. 函数参数的解构赋值
function move({x = 0, y = 0} = {}) {
return [x, y];
}
move({x: 3, y: 8}); // [3, 8]
move({x: 3}); // [3, 0]

------------------------
字符串的扩展
------------------------
1. unicode表示法: 只要将码点放入大括号，就能正确解读该字符
"\u{20BB7}" //7

2. codePointAt: 返回的是码点的十进制值
如果想要十六进制的值，可以使用toString方法转换一下。
let s = '