ES6(Reflect，Promise)

一、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 // 1

Reflect.set(myObject, 'foo', 2);
myObject.foo // 2

Reflect.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 code

  if (/* 异步操作成功 */){
    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);
});