es6

新特性总览

1. let const (变量声明)
1. 解构赋值
1. Promise 对象
1. async / await (nodejs controller中经常使用，查询数据库)
1. 箭头函数
1. 模板字符串
1. 字符扩展方法:
- 1. 查找 String.prototype.includes() startWith endsWith
1. 函数引入了: rest参数 fn(...param) & 箭头函数
1. ... 扩展运算符
1. 数组扩展方法:
- 1. 查找：find() findIndex() includes()
- 1. 遍历：keys() entries() values()
1. 对象扩展方法:
- 1. Object.assign()
- 1. Object.keys() Object.entries() Object.setPrototypeOf() Object.values()
- 1. Object.getOwnPropertyDescriptors()
- 1. __proto__属性，Object.()，Object.getPrototypeOf() 设置对象的原型，非常重要
1. 循环：for...of
1. Class
1. Module
- 1. import
- 1. export
1. Number isFinite isNaN isInteger
1. Set Map 两种新的数据类型(数据结构)
- 1. Set (去重的数组)
  - 1. size
  - 1. has add delete clear()
  - 1. 遍历: keys values entries 返回的都是一个遍历器对象
- 1. Map (键值类型没有限制的map)
  - 1. set get
  - 1. has delete clear()
  - 1. 遍历: keys values entries 返回的都是一个遍历器对象
1. Iterator 和 for...of 循环 (引入了遍历器对象的概念,与之搭配的是新的for of 遍历方法)

let const

let 用来声明变量，并且会在当前作用域形成代码块 TDZ(Temporal Dead Zone)暂时性死区
const 用来声明常量，所谓常量就是物理指针不可以更改的变量。即任何改变内存地址的操作都不允许。除此之外特性跟 let 一样。对于引用类型的数据，在使用时要注意。
const 声明的对象或数组可以改变，只要不改变其内存地址。不能做到冻结对象，要冻结对象还要使用Object.freeze();

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

1
2
3
4
5
6
7
8

let声明变量，变量不会提升

箭头函数

除了便捷的写法外，注意this的指向问题：

默认绑定外层this

const obj = {
	a: function() {
		console.log(this);
	}    
}
obj.a()  //打出的是obj对象

1
2
3
4
5
6

const obj = {
    a: () => {
        console.log(this);
    }
}
obj.a()  //打出来的是window

1
2
3
4
5
6

不能用call方法修改里面的this

const obj = {
    a: () => {
        console.log(this);
    }
}
obj.a.call('123')  //打出来的结果依然是window对象

1
2
3
4
5
6

箭头函数不会创建自己的this,它只会从自己的作用域链的上一层继承this。箭头函数不使用自身的this，而是一层一层的向上查找，直到有this，即箭头函数的this指向的是外层不是箭头函数的this。

const obj = {
    a: function() { console.log(this) },
    b: {
    	c: function() {console.log(this)}
	}
}
obj.a()  // 打出的是obj对象, 相当于obj.a.call(obj)
obj.b.c() //打出的是obj.b对象, 相当于obj.b.c.call(obj.b)

1
2
3
4
5
6
7
8

const obj = {
    a: function() { console.log(this) },
    b: {
    	c: () => {console.log(this)}
	}
}
obj.a()   //没有使用箭头函数打出的是obj
obj.b.c()  //打出的是window对象！！

1
2
3
4
5
6
7
8

for in、for of、forEach

forEach 用来遍历数组，遍历的是索引，但是不能中断循环(break或return）
for in 可遍历数组和对象，遍历的是索引，但会把原型方法和可枚举属性全部遍历出来（可用hasOwnPropery筛选掉），且不能保证对象的内部顺序，不推荐用来遍历数组。
for of 用来遍历iterable类型的对象，遍历的是元素值，Array、Map和Set都属于iterable类型。(普通对象{a: '1', b: '2', c: '3', d: '4'}不是iterable，不可以遍历)

class

基本框架：

	//变量方法名 可计算成员名称
	let funStr = 'get' + 'Age';
	class A {
		//静态属性
	    static sex = 'male';

	    constructor (name, job) {
	        this.name = name;
	        this.job = job || 'unkown';
	    }
	    
	    sayName () {
	        return this.name;
	    }
		
		//静态方法
	    static sayHeight () {
	        return '188cm';
	    }
	    
	    //getter
	    get myJob () {
	        return this.job;
	    }
	    
	    //setter
	    set myJob (job) {
	        this.job = job;
	    }
		
		//可计算成员名称
	    [funStr] () {
	        return 18;
	    }
	}


	console.log(A.sex);  // 'male'
	console.log(A.sayHeight()); // '188cm'

	let a = new A('Tom'); 
	console.log(a.sayName()); // 'Tom'
	console.log(a.myJob); // 'unkown'
	a.myJob = 'teacher';
	console.log(a.myJob); // 'teacher'
	console.log(a.getAge()); // '18'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

继承：

	class B extends A {
	    static sex = 'female';
	    constructor (name, job, married) {
	        super(name, job);
            this.married = married;
	    }
	    
	    sayName () {
            //super.sayName();
	        return 'Hi, I\'m ' + this.name;
	    }
	}

	console.log(B.sex);  // 'female'
	console.log(B.sayHeight()); // '188cm'

	let b = new B('Lucy', 'nurse', true);

	console.log(b.sayName()); // 'Hi, I'm Lucy'
	console.log(b.myJob); // 'nurse'
	b.myJob = 'teacher';
	console.log(b.myJob); // 'teacher'
	console.log(b.getAge()); // '18'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

参考 1 2

Object的静态方法

Object.is() - 比较两个对象是否相同，值类型对象比较值是否相等，引用类型对象比较内存地址是否相同。
Object.keys() - 返回对象的可枚举属性数组。
Object.assign() - 将多个对象的可枚举属性拷贝到目标对象上，并且返回赋值后的目标对象
Object.create() - 获取一个类的原型（prototype）对象，返回值为参数类的原型对象。可用于类继承。
Object.defineProperties() - 给对象定义属性，如果存在该属性，则用新定义的属性更新已存在的属性，如果不存在该属性，则添加该属性。
Object.defineProperty() - 在对象上定义新属性，或修改对象现有属性，并返回该对象。
Object.entries() - 遍历获取对象上所有可枚举的属性，返回结果是一个二维数组[['key1', 'value1'], ['key2', 'value2'], ...]
Object.freeze() - 将一个对象上的属性冻结，阻止添加、删除、更新属性到该对象及其原型。返回被冻结的对象。
Object.getOwnPropertyDescriptors() - 获取一个对象所有的直接属性的描述信息（直接在对象上的属性，而不是原型链上的属性）。
Object.getOwnPropertyDescriptor() - 获取一个对象指定名称的直接属性的描述信息（直接在对象上的属性，而不是原型链上的属性），存在则返回该属性的描述信息，不存在则返回undefined。
Object.getOwnPropertyNames() - 获取一个对象所有的直接属性的属性名称（直接在对象上的属性，而不是原型链上的属性）。返回属性名称字符串数组。
Object.getOwnPropertySymbols() - 获取对象上所有的Symbol类型的属性列表。
Object.getPrototypeOf() - 获取一个对象上的原型对象，其功能和 obj._proto_等同。

参考 1

promise 异常捕获

一般情况下，当Promise调用链中抛出一个异常时，异常信息会沿着链路向后传递，直至被捕获。

Q1: 在promise调用链中如何在某个then中捕获到异常，但是不停止后面then的执行？

若链路中也对异常进行了捕获，则后续的函数可能会继续执行，——

//then添加第二个参数捕获异常，不影响后面then的执行
Promise.resolve()
    .then(() => {
        console.log('[onFulfilled_1]');
        throw 'throw on onFulfilled_1';
    })
    .then(() => {
        console.log('[onFulfilled_2]');
    }, err => {     // 捕获异常
        console.log('[onRejected_2]', err);
    })
    .then(() => {   // 该函数将被调用
        console.log('[onFulfilled_3]');
    })
    .catch(err => {
        console.log('[catch]', err);
    });
//[onFulfilled_1]
//[onRejected_2] throw on onFulfilled_1
//[onFulfilled_3]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Q2: 在promise调用链中如何在某个then中捕获到异常，立即停止后面then的执行？

Promise.prototype.then(onFulfilled, onRejected) 若onFulfilled或onRejected是一个函数，当函数返回一个新Promise对象时，原Promise对象的状态将跟新对象保持一致，详见Promises/A+标准。

因此，当新对象保持“pending”状态时，原Promise链将会中止执行。

Promise.resolve()
    .then(() => {
        console.log('[onFulfilled_1]');
        return new Promise(() => {}); // 返回“pending”状态的Promise对象
    })
    .then(() => {                   // 后续的函数不会被调用
        console.log('[onFulfilled_2]');
    })
    .catch(err => {
        console.log('[catch]', err);
    });
//[onFulfilled_1]

1
2
3
4
5
6
7
8
9
10
11
12

Q3: 为了防止有漏掉的 Promise 异常，建议在全局增加一个对 unhandledrejection 的监听，用来全局监听Uncaught Promise Error。使用方式：

window.addEventListener('unhandledrejection', function(e) {
    console.log(e);
});

1
2
3

然而自己在浏览器上常识并不好使。。。。

Symbol

可用来实现私有变量

// 定义symbol
const _x = Symbol('x')

class A {
    constructor (x) {
        // 利用symbol声明私有变量
        this[_x] = x
    }
    showX () {
        return this[_x]
    }
}

let a = new A(1);

// 自行定义一个相同的Symbol
const x = Symbol('x')
// 无法访问
a[x]        // undefined
// 可以访问
a.showX()   //1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

参考 1

Symbol.iterator

如果对象具有 Symbol.iterator 属性，则表示它是可迭代的。在 ES2015 中，字符串和集合对象（如Set, Map 和 Array）带有Symbol.iterator 属性，因此是可迭代的。

如

普通对象不可迭代，但如果在其上定义了 Symbol.iterator 属性，则它可变为可迭代对象

如

以上过程可以使用生成器（ generator ）函数进行大大简化：

Symbol、Symbol.for、Symbol.keyFor

Symbol('red') === Symbol('red');   //false
Symbol.for('red') === Symbol.for('red');   //true

1
2

var s1 = Symbol.for("foo");
Symbol.keyFor(s1) // "foo"

var s2 = Symbol("foo");
Symbol.keyFor(s2) // undefined

1
2
3
4
5

Symbol应用

使用Symbol来作为对象属性名(key)
使用Symbol来替代常量
使用Symbol定义类的私有属性/方法

参考

Proxy/Reflect

Proxy 拦截对象行为

var obj = new Proxy({}, {
    get: function (target, key, receiver) {
        console.log(`getting ${key}!`);
        return Reflect.get(target, key, receiver);
    },
    set: function (target, key, value, receiver) {
        console.log(`setting ${key}!`);
        return Reflect.set(target, key, value, receiver);
    }
});

1
2
3
4
5
6
7
8
9
10

Reflect

为操作对象而提供的新API
不是构造函数，只这么调用 Reflect['method']
Proxy 有的方法，Reflect都有
举例：
- 'a' in obj --> Reflect.has(obj, 'a);
- delete obj.a --> Reflect.deleteProperty(obj, 'a');
- Object.defineProperty(target, property, attributes) 失败会报错 --> Reflect.defineProperty(target, property, attributes) 返回true/false
- 等等

参考 1

async/await

特点：

async 函数是 Generators和Promises特性功能的语法糖
建立在 promise 之上。它会声明一个异步函数，并隐式地返回一个Promise。因此可以直接return变量，无需使用 Promise.resolve 进行转换。
和 promise 一样，是非阻塞的。但不用写 then 及其回调函数，这减少代码行数，也避免了代码嵌套。而且，所有异步调用，可以写在同一个代码块中，无需定义多余的中间变量。
它的最大价值在于，可以使异步代码在形式上更接近于同步代码。
与 await 一起使用，await 只能在 async 函数体内。
await 是个运算符，用于组成表达式，它会阻塞后面的代码。如果等到的是 Promise 对象，则得到其 resolve 值。否则，会得到一个表达式的运算结果。

举例：某业务，每一个步骤都需要之前每个步骤的结果。promise 写法：

function doIt() {
    console.time("doIt");
    const time1 = 300;
    step1(time1)
        .then(time2 => {
            return step2(time1, time2)
                .then(time3 => [time1, time2, time3]);
        })
        .then(times => {
            const [time1, time2, time3] = times;
            return step3(time1, time2, time3);
        })
        .then(result => {
            console.log(`result is ${result}`);
        });
}
doIt();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

async/await 写法：

async function doIt() {
    console.time("doIt");
    const time1 = 300;
    const time2 = await step1(time1);
    const time3 = await step2(time1, time2);
    const result = await step3(time1, time2, time3);
    console.log(`result is ${result}`);
}
doIt();

1
2
3
4
5
6
7
8
9

await 在等什么

如果它等到的不是一个 Promise 对象，那 await 表达式的运算结果就是它等到的东西。
如果它等到的是一个 Promise 对象，它会阻塞后面的代码，等着 Promise 对象 resolve，然后得到 resolve 的值，作为 await 表达式的运算结果。

1 2 3

Set、WeakSet 和 Map、 WeakMap

Set
- 成员唯一、无序且不重复
- [value, value]，键值与键名是一致的（或者说只有键值，没有键名）
- 操作方法有：add() 、 delete() 、 has() 、 clear()
- 可以遍历，方法有：keys() 、 values() 、 entries() 、 forEach()
WeakSet
- 成员都是对象
- 成员都是弱引用，可以被垃圾回收机制回收，可以用来保存DOM节点，不容易造成内存泄漏
- 操作方法有：add() 、 delete() 、 has()
- 不能遍历
Map
- 本质上是键值对的集合，类似集合
- 可以遍历，方法很多可以跟各种数据格式转换
WeakMap
- 只接受对象最为键名（null除外），不接受其他类型的值作为键名
- 键名是弱引用，键值可以是任意的，键名所指向的对象可以被垃圾回收，此时键名是无效的
- 操作方法有： get() 、 set() 、 delete() 、 has()
- 不能遍历

对弱引用的理解

WeakSet 类似于 Set ，仅存储对象。WeakMap 类似于 Map，键必须是对象。
WeakMap/WeakSet 中对对象是弱引用，垃圾回收机制不会考虑 WeakMap 对该对象的引用，也就是 JavaScript不会阻止将对象从内存移除。
WeakSet / WeakMap 没有部署 Iterator 接口，所以不能用for...of遍历。因为垃圾回收机制随时会对他们的值进行回收，所以个数并不确定。

let obj = {id: 1}
const wm = new WeakMap([[obj, 'sina']])
obj = null  // 重写obj {id: 1}将会从内存移除，不考虑 wm 还在引用它

1
2
3

使用

记录访问次数

let jack = { name: "jack" };
const vistedCount = new WeakMap();
vistedCount.set(jack, 123);
// 当 jack 离开，就不需要保存其访问记录
jack = null;
// 除了 vistedCount 没有其他引用了
// 所以这个对象会自动的从内存和 vistedCount 中删除，不会造成内存泄漏

1
2
3
4
5
6
7

注册监听事件

const listener = new WeakMap();
listener
    .set(ele1, func1);
    .set(ele2, func2);
ele1.addEventListener('click', listener.get(ele1), false);
ele2.addEventListener('click', listener.get(ele2), false);
// 监听函数放在 WeakMap 中，一旦DOM移除，监听函数也随之从内存移除，不会造成内存泄漏。

1
2
3
4
5
6
7

let 、cosnt 与 var 的区别

let:

不存在变量提升
暂时性死区
不允许重复声明 const
与 let 类似，声明的变量指向同一地址，不允许改变，因此基本类型不能改变值，引用类型可以改变内部属性，但不能改变指向。

箭头函数与普通函数区别

箭头函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象，箭头函数没有自己的this。
不可以当作构造函数，也就是说，不可以使用new命令，没有super、new.target。没有自己的this，因此不可以用作构造函数，不能用 call()，apply()，bind()这些方法去改变 this 的指向
不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
不可以使用yield命令，因此箭头函数不能用作 Generator 函数。
没有 prototype 属性

← node 问题 →

# es6

# 新特性总览

# let const

# 箭头函数

# for in、for of、forEach

# class

# Object的静态方法

# promise 异常捕获

# Symbol

# 可用来实现私有变量

# Symbol.iterator

# Symbol、Symbol.for、Symbol.keyFor

# Symbol应用

# Proxy/Reflect

# Reflect

# async/await

# Set、WeakSet 和 Map、 WeakMap

# let 、cosnt 与 var 的区别

# 箭头函数与普通函数区别

es6

新特性总览

let const

箭头函数

for in、for of、forEach

class

Object的静态方法

promise 异常捕获

Symbol

可用来实现私有变量

Symbol.iterator

Symbol、Symbol.for、Symbol.keyFor

Symbol应用

Proxy/Reflect

Reflect

async/await

Set、WeakSet 和 Map、 WeakMap

let 、cosnt 与 var 的区别

箭头函数与普通函数区别