drunk.Promise

根据ES6 Promise API实现的一个Promise类，与ES6 Promise不同的是fulfill后并不是异步执行回调，而是立即执行。同时添加了done与cancel两个实例方法和timeout类方法，以方便drunk框架内部的一些实现。

实例化

new drunk.Promise(executor: (resolve, reject) => any)

var resolvedPromise = new drunk.Promise((resolve, reject) => {
  resolve('resolved');
});

var rejectedPromise = new drunk.Promise((resolve, reject) => {
  reject('rejected');
});

实例方法

• drunk.Promise.prototype.then

  接受两个函数回调，第一个函数会在该Promise为resolved状态时执行，第二个函数会在rejected状态时执行。返回一个新的Promise实例。

  then(onResolved?: (value) => any, onRejected?: (reason) => any): drunk.Promise

  var promise1 = new drunk.Promise(resolve => {
    resolve('resolved');
  });
  var promise2 = promise1.then((value) => {
    console.log(value); // 'resolved'
  });
  console.log(promise1 == promise2); // false
  

• drunk.Promise.prototype.catch

  当状态为rejection时执行。resolved状态的回调执行出现异常时也会转为rejected状态。返回一个新的Promise实例。

  catch(onRejected?: (reason: any) => any): drunk.Promise

  new drunk.Promise((resolve, reject) => {
    throw new Error('rejected');
    resolve('这行永远不会执行');
  }).catch(err => {
    console.log(err.message); // 'rejected'
  });
  

• drunk.Promise.prototype.done

  与then方法一样，只是没有返回值，这样可以在某些不需要返回新的Promise的场景中使用。

  done(onResolved?: (value) => any, onRejected?: (reason) => any): void

  var promise = new drunk.Promise((resolve, reject) => {
    reject('rejected');
  }).done(null, err => {
    console.log(err); // 'rejected'
  });
  console.log(promise); // undefined
  

• drunk.Promise.prototype.cancel

  立即设置该Promise实例的状态为rejected，会以一个Error('Canceled')的对象触发所有rejected回调。

  cancel(): void

  var promise = new drunk.Promise(resolve => {
    setTimeout(() => {
      resolve('这行永远不会执行');
    }, 1000);
  });
  promise.done(null, err => {
    console.log(err.message); // 'Canceled'
  });
  promise.cancel();
  

类方法

• drunk.Promise.resolve

  根据参数创建一个状态为resolved的Promise实例。

  resolve(value: any): drunk.Promise

  drunk.Promise.resolve('resolved').then(res => {
    console.log(res); // 'resolved'
  });
  

• drunk.Promise.reject

  根据参数创建一个状态为rejected的Promise实例。

  reject(value: any): drunk.Promise

  drunk.Promise.reject('rejected').catch(res => {
    console.log(res); // 'rejected'
  });
  

• drunk.Promise.all

  包装一个列表，检测列表的所有Promise实例是否都为resolved状态，然后触发resolved状态，任何一个列表中的Promise实例的状态为rejected都会立即触发rejected状态。

  all(promises: Array<Promise|any>): drunk.Promise

  drunk.Promise.all([
    123,
    drunk.Promise.reject('rejected'),
    drunk.Promise.resolve('resolved')
  ]).then(() => {
    // 永远不会被调用
  }).catch(res => {
    console.log(res); // 'rejected'
  });
  
  drunk.Promise.all([
    1,
    drunk.Promise.resolve(2),
    new drunk.Promise(resolve => {
      setTimeout(() => resolve(3), 1000);
    })
  ]).done(res => {
    console.log(res); // [1, 2, 3]
  });
  

• drunk.Promise.race

  包装一个列表，检测列表中只要任意一个值为Promise可以resolved的值，则以resolved状态结束，如果都为pending状态的Promise实例，以第一个Promise实例的状态为结果。

  race(promises: Array<Promise|any>): drunk.Promise

  drunk.Promise.race([
    123,
    drunk.Promise.reject('rejected')
  }).then(res => {
    console.log(res); // 123
  });
  
  drunk.Promise.race([
    drunk.Promise.reject('rejected'),
    drunk.Promise.resolve('resolved'),
    123
  ]).catch(err => {
    console.log(err); // 'rejected'
  });
  

• drunk.Promise.timeout

  setTimeout与Promise结合的一个快捷工具方法，可以更加方便的设置一个定时器并使用Promise。

  timeout(ms: number): drunk.Promise

  var startTime = Date.now();
  drunk.Promise.timeout(1000).done(() => {
    console.log(Date.now() - startTime); // 1000 ,有可能有误差
  });