ES6特性解释

let和const

let在块级作用域有效。不存在之前的var的作用域提升。

const意思是只读的变量。不可以在声明之后再改变值。

const指向对象的时候，对象可以改变属性，但是对象不能变。

{
let a=1;
}
for(let i=0;i<10;i++){
}

变量的解构

1.数组的解构。

左边的变量对等于右边的值。

值的长度可变，不存在则等于undefined

右边的结构要求实现Iterator ，数组、Set都算。

-可以在定义之前指定默认值，如果右边不存在则使用默认值，（null也算赋值）

let [a, b, c] = [1, 2, 3];
let [x, y, z] = new Set(['a', 'b', 'c']);
let [foo = true] = [];

2.对象的解构

变量名等于属性名对应的值

可以指定对象名对应的值

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

3.字符串也可以解构

const [a, b, c, d, e] = 'hello';
let {length : len} = 'hello';

4.函数参数的解构

function add([x, y]){
return x + y;
}
add([1, 2]); // 3

5.解构的表达式中不能使用圆括号’()’,一旦使用就会报错

字符串新方法

“\u{41}\u{42}\u{43}”表示法

codePointAt获取字符串的十进制

fromCodePoint从进制转字符串

for…of接口

at返回下标对应的字符

normalize

includes、startsWith、endsWith

repeat

padStart、padEnd补全

模板字符串

aaa${name}

标签模板

String.raw

Hi\n${2+3}!

以上做一个备注

正则的扩展

new RegExp(/abc/ig, ‘i’)

String.prototype.match调用RegExp.prototype[Symbol.match]

u修饰符

var result = text.match(/[\s\S]/gu);
return result ? result.length : 0;
//返回中文字符串的正确长度

y修饰符

sticky

flags

s修饰符

数值扩展

0b二进制和0o八进制表示法

Number.isFinite()和Number.isNaN()

Number.parseInt(), Number.parseFloat()

Number.isInteger()是否为整数

Number.EPSILON常量

Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER上下限

Math.trunc()去掉小数部分

Math.sign()正负数判断

Math.cbrt() 计算立方根

Math.clz32()

Math.imul()

Math.fround()

Math.hypot()

Math.expm1()

Math.log1p()

Math.log10()

Math.log2()

指数运算符**

函数的扩展

函数参数默认值，默认值在最后

length返回没有默认值的参数个数

rest 参数（形式为…变量名）

name返回函数名称

箭头函数。

var f = () => 5;
// 等同于
var f = function () { return 5 };

var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2) {
return num1 + num2;
};

1.函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
2.不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
3.不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
4.不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

::绑定 this

尾调用，优化

数组的扩展

扩展运算符…

Array.from将类似数组（包含length属性）和实现了Iterable的对象转为数组。第二个参数是处理方法

Array.of()将参数转为数组

copyWithin（开始位置，开始读取位置，结束读取位置）

find，findIndex

fill（填充值，开始位置，结束位置）

entries()，keys() 和 values()

includes（是否包含的值，开始查询的位置）

属性的扩展

属性的简洁表示法

字面量定义对象，不能同时使用简洁表示法

let propKey = 'foo';

let obj = {
[propKey]: true,
['a' + 'bc']: 123
};

方法的 name 属性

Object.is()

Object.assign()

1.for…in循环遍历对象自身的和继承的可枚举属性（不含 Symbol 属性）。

2.Object.keys返回一个数组，包括对象自身的（不含继承的）所有可枚举属性（不含 Symbol 属性）

3.Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）。

4.Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性。

5.Reflect.ownKeys返回一个数组，包含对象自身的所有属性，不管属性名是 Symbol 或字符串，也不管是否可枚举。

Object.getOwnPropertyDescriptors()

Object.create

Object.setPrototypeOf()和Object.getPrototypeOf()

Object.keys()，Object.values()，Object.entries()

对象的扩展运算符…

Symbol

ES6 引入了一种新的原始数据类型Symbol，表示独一无二的值。它是 JavaScript 语言的第七种数据类型，前六种是：undefined、null、布尔值（Boolean）、字符串（String）、数值（Number）、对象（Object）。

let s = Symbol();
typeof s
// "symbol"

var mySymbol = Symbol();

// 第一种写法
var a = {};
a[mySymbol] = 'Hello!';

// 第二种写法
var a = {
[mySymbol]: 'Hello!'
};

// 第三种写法
var a = {};
Object.defineProperty(a, mySymbol, { value: 'Hello!' });

// 以上写法都得到同样结果
a[mySymbol] // "Hello!"

Object.getOwnPropertySymbols可以获取到对象的Symbol属性

Symbol.for()，Symbol.keyFor()

Set和Map

Set

const s = new Set();

[2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x));

for (let i of s) {
console.log(i);
}
// 2 3 5 4

Set.prototype.constructor：构造函数，默认就是Set函数。

Set.prototype.size：返回Set实例的成员总数。

add(value)：添加某个值，返回Set结构本身。

delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。

has(value)：返回一个布尔值，表示该值是否为Set的成员。

clear()：清除所有成员，没有返回值。

keys()：返回键名的遍历器

values()：返回键值的遍历器

entries()：返回键值对的遍历器

forEach()：使用回调函数遍历每个成员

WeakSet

1.WeakSet 的成员只能是对象，而不能是其他类型的值。

2.WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用

Map

const map = new Map([
['name', '张三'],
['title', 'Author']
]);

map.size // 2
map.has('name') // true
map.get('name') // "张三"
map.has('title') // true
map.get('title') // "Author"

keys()：返回键名的遍历器。

values()：返回键值的遍历器。

entries()：返回所有成员的遍历器。

forEach()：遍历 Map 的所有成员。

WeakMap

1.WeakMap只接受对象作为键名（null除外），不接受其他类型的值作为键名。

2.WeakMap的键名所指向的对象，不计入垃圾回收机制。

WeakMap 与 Map 在 API 上的区别主要是两个，一是没有遍历操作（即没有key()、values()和entries()方法），也没有size属性。因为没有办法列出所有键名，某个键名是否存在完全不可预测，跟垃圾回收机制是否运行相关。这一刻可以取到键名，下一刻垃圾回收机制突然运行了，这个键名就没了，为了防止出现不确定性，就统一规定不能取到键名。二是无法清空，即不支持clear方法。因此，WeakMap只有四个方法可用：get()、set()、has()、delete()。

Proxy

1.get(target, propKey, receiver)

2.set(target, propKey, value, receiver)

3.has(target, propKey)

4.deleteProperty(target, propKey)。用于拦截delete操作

5.ownKeys(target)

6.getOwnPropertyDescriptor(target, propKey)

7.defineProperty(target, propKey, propDesc)。拦截了Object.defineProperty操作

8.preventExtensions(target)

9.getPrototypeOf(target)

10.isExtensible(target)

11.setPrototypeOf(target, proto)

12.apply(target, object, args)

13.construct(target, args)。方法用于拦截new命令

Reflect

1.将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。也就是说，从Reflect对象上可以拿到语言内部的方法。

2.修改某些Object方法的返回结果，让其变得更合理。比如，Object.defineProperty(obj, name, desc)在无法定义属性时，会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false。

Reflect.apply(target,thisArg,args)

Reflect.construct(target,args)

Reflect.get(target,name,receiver)

Reflect.set(target,name,value,receiver)

Reflect.defineProperty(target,name,desc)

Reflect.deleteProperty(target,name)

Reflect.has(target,name)

Reflect.ownKeys(target)

Reflect.isExtensible(target)

Reflect.preventExtensions(target)

Reflect.getOwnPropertyDescriptor(target, name)

Reflect.getPrototypeOf(target)

Reflect.setPrototypeOf(target, prototype)

Promise

var promise = new Promise(function(resolve, reject) {
// ... some code

if (/* 异步操作成功 */){
resolve(value);
} else {
reject(error);
}
});

promise.then(function(value) {
// success
}, function(error) {
// failure
});

Iterator（遍历器）

1.创建一个指针对象，指向当前数据结构的起始位置。也就是说，遍历器对象本质上，就是一个指针对象。

2.第一次调用指针对象的next方法，可以将指针指向数据结构的第一个成员。

3.第二次调用指针对象的next方法，指针就指向数据结构的第二个成员。

4.不断调用指针对象的next方法，直到它指向数据结构的结束位置。

const obj = {
[Symbol.iterator] : function () {
return {
next: function () {
return {
value: 1,
done: true
};
}
};
}
};

Generator

Generator 函数有多种理解角度。从语法上，首先可以把它理解成，Generator 函数是一个状态机，封装了多个内部状态。

执行 Generator 函数会返回一个遍历器对象，也就是说，Generator 函数除了状态机，还是一个遍历器对象生成函数。返回的遍历器对象，可以依次遍历 Generator 函数内部的每一个状态。

形式上，Generator 函数是一个普通函数，但是有两个特征。一是，function关键字与函数名之间有一个星号；二是，函数体内部使用yield表达式，定义不同的内部状态（yield在英语里的意思就是“产出”）。

function* helloWorldGenerator() {
yield 'hello';
yield 'world';
return 'ending';
}

var hw = helloWorldGenerator();

yield 表达式

（1）遇到yield表达式，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。

（2）下一次调用next方法时，再继续往下执行，直到遇到下一个yield表达式。

（3）如果没有再遇到新的yield表达式，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。

（4）如果该函数没有return语句，则返回的对象的value属性值为undefined。

需要注意的是，yield表达式后面的表达式，只有当调用next方法、内部指针指向该语句时才会执行，因此等于为 JavaScript 提供了手动的“惰性求值”（Lazy Evaluation）的语法功能。

async

var fs = require('fs');

var readFile = function (fileName) {
return new Promise(function (resolve, reject) {
fs.readFile(fileName, function(error, data) {
if (error) return reject(error);
resolve(data);
});
});
};

var gen = function* () {
var f1 = yield readFile('/etc/fstab');
var f2 = yield readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};
//等同于
var asyncReadFile = async function () {
var f1 = await readFile('/etc/fstab');
var f2 = await readFile('/etc/shells');
console.log(f1.toString());
console.log(f2.toString());
};

Class

//定义类
class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}

toString() {
return '(' + this.x + ', ' + this.y + ')';
}
static classMethod() {
return 'hello';
}
}
//继承
class Point {
}

class ColorPoint extends Point {
}

类的修饰

@testable
class MyTestableClass {
// ...
}

function testable(target) {
target.isTestable = true;
}

MyTestableClass.isTestable // true

Module 的语法

import { stat, exists, readFile } from 'fs';

ES6 的模块自动采用严格模式，不管你有没有在模块头部加上”use strict”;。

严格模式主要有以下限制。

变量必须声明后再使用

函数的参数不能有同名属性，否则报错

不能使用with语句

不能对只读属性赋值，否则报错

不能使用前缀0表示八进制数，否则报错

不能删除不可删除的属性，否则报错

不能删除变量delete prop，会报错，只能删除属性delete global[prop]

eval不会在它的外层作用域引入变量

eval和arguments不能被重新赋值

arguments不会自动反映函数参数的变化

不能使用arguments.callee

不能使用arguments.caller

禁止this指向全局对象

不能使用fn.caller和fn.arguments获取函数调用的堆栈

增加了保留字（比如protected、static和interface）

上面这些限制，模块都必须遵守。由于严格模式是 ES5 引入的，不属于 ES6，所以请参阅相关 ES5 书籍

其中，尤其需要注意this的限制。ES6 模块之中，顶层的this指向undefined，即不应该在顶层代码使用this。