一、Reflect

这里空过了Proxy

1.了解Rflect

用来操作对象的API

• 将Object对象的一些明显属于语言内部的方法,放到Reflect对象上
• 修改某些Object方法的返回结果，让其变得更合理

// 老写法
try {Object.defineProperty(target, property, attributes);// success
} catch (e) {// failure
}// 新写法
if (Reflect.defineProperty(target, property, attributes)) {// success
} else {// failure
}

•   让Object操作都变成函数行为:命令式转为函数式

// 老写法
'assign' in Object // true// 新写法
Reflect.has(Object, 'assign') // true

2.静态方法 

• Reflect.apply(target, thisArg, args)

• Reflect.construct(target, args)
• Reflect.get(target, name, receiver)

var myObject = {foo: 1,bar: 2,get baz() {return this.foo + this.bar;},
}Reflect.get(myObject, 'foo') // 1
Reflect.get(myObject, 'bar') // 2
Reflect.get(myObject, 'baz') // 3

//修改了this指向到新的对象上
var myObject = {foo: 1,bar: 2,get baz() {return this.foo + this.bar;},
};var myReceiverObject = {foo: 4,bar: 4,
};Reflect.get(myObject, 'baz', myReceiverObject) // 8

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

var myObject = {foo: 1,set bar(value) {return this.foo = value;},
}myObject.foo // 1Reflect.set(myObject, 'foo', 2);
myObject.foo // 2Reflect.set(myObject, 'bar', 3)
myObject.foo // 3

//修改this
var myObject = {foo: 4,set bar(value) {return this.foo = value;},
};var myReceiverObject = {foo: 0,
};Reflect.set(myObject, 'bar', 1, myReceiverObject);
myObject.foo // 4
myReceiverObject.foo // 1

• 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 

1.含义

语法上说，Promise 是一个对象：用来解决回调函数

• 可以获取异步操作的消息
• Promise代表一个异步对象
• 异步操作三种状态:pending（进行中）、fulfilled（已成功）和rejected（已失败）
• 从pending变为fulfilled和从pending变为rejected都叫做已定性：resolved

缺点：

• 一旦新建它就会立即执行，无法中途取消
• 如果不设置回调函数，Promise内部抛出的错误，不会反应到外部
• 当处于pending状态时，无法得知目前进展到哪一个阶段

2. 使用 

Promise对象是一个构造函数，用来生成Promise实例

promise接收函数作为参数，函数包含的参数：resolve和reject

• resolve：pending 变成 resolved（也就是fulfilled状态：这里是ES6文章规定）
• reject：pending 变成  rejected

const promise = new Promise(function(resolve, reject) {// ... some codeif (/* 异步操作成功 */){resolve(value);} else {reject(error);}
});

then方法接受两个回调函数参数

• 第一个回调函数是Promise对象的状态变为resolved时调用
• 第二个回调函数是Promise对象的状态变为rejected时调用。

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

 timeout方法返回一个Promise实例，表示一段时间以后才会发生的结果。过了指定的时间（ms参数）以后，Promise实例的状态变为resolved，就会触发then方法绑定的回调函数

function timeout(ms) {return new Promise((resolve, reject) => {setTimeout(resolve, ms, 'done');});
}timeout(100).then((value) => {console.log(value);
});