靜態(tài)方法

Promise.all(iterable)

執(zhí)行所有的Promise

var promise = Promise.resolve(3);
Promise.all([true, promise]).then(values => {
  console.log(values); // [true, 3]
},error=>{
  console.log(err)  
});

Promise.race(iterable)

執(zhí)行所有的Promise,但是顯示最快的一個(gè)的結(jié)果

Promise.race([new Promise((resolve, reject)=>{
  setTimeout(reject, 500, "five");
}), new Promise((resolve, reject)=>{
  setTimeout(resolve, 100, "six");
})]).then(value=>{
   console.log(value);
},reason=>{
  console.log(reason);
});

Promise.reject(reason)

返回Promise 并且說(shuō)明原因拒絕

Promise.resolve(value)

返回Promise 并且給予解決的值，如果value是Promise,則會(huì)取里面的resolve的值

對(duì)象方法

Promise.prototype.then(onFulfilled, onRejected)

onFulfilled對(duì)應(yīng) resolve, onRejected對(duì)應(yīng) reject。
onFulfilled的默認(rèn)值是value=>value,onRejected的默認(rèn)值是reason=>throw reason
2個(gè)方法參數(shù)可以設(shè)置返回值，或者返回一個(gè)新的promise對(duì)象，可以鏈?zhǔn)?code>then方法

Promise.prototype.catch(onRejected)

類同 Promise.prototype.then(undefined, onRejected)

具體實(shí)現(xiàn)

狀態(tài)機(jī)

var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;

function Promise(fn) {
  // 存儲(chǔ)當(dāng)前的狀態(tài) PENDING, FULFILLED or REJECTED
  var state = PENDING;
  // 存儲(chǔ)當(dāng)前的結(jié)果或者錯(cuò)誤 FULFILLED or REJECTED
  var value = null;
  // 存儲(chǔ)方法用于`then`或者`done`
  var handlers = [];
}

設(shè)置回調(diào)

function fulfill(result) {
    state = FULFILLED;
    value = result;
    handlers.forEach(handle);
    handlers = null;
}

function reject(error) {
    state = REJECTED;
    value = error;
    handlers.forEach(handle);
    handlers = null;
}
function handle(handler) {
    if (state === PENDING) {
      handlers.push(handler);
    } else {
      if (state === FULFILLED &&
        typeof handler.onFulfilled === 'function') {
        handler.onFulfilled(value);
      }
      if (state === REJECTED &&
        typeof handler.onRejected === 'function') {
        handler.onRejected(value);
      }
    }
}
this.done = function (onFulfilled, onRejected) {
    // 確保我們始終是異步
    setTimeout(function () {
      handle({
        onFulfilled: onFulfilled,
        onRejected: onRejected
      });
   }, 0);
}
this.catch = function (onRejected) {
   this.done(undefined,onRejected)
}

處理

// 檢查值是不是`Promise`如果是則返回`Promise`的then方法
function getThen(value) {
  var t = typeof value;
  if (value && (t === 'object' || t === 'function')) {
    var then = value.then;
    if (typeof then === 'function') {
      return then;
    }
  }
  return null;
}

//如果是`Promise`則執(zhí)行then并且，保證執(zhí)行一次
function doResolve(fn, onFulfilled, onRejected) {
  var done = false;
  try {
    fn(function (value) {
      if (done) return
      done = true
      onFulfilled(value)
    }, function (reason) {
      if (done) return
      done = true
      onRejected(reason)
    })
  } catch (ex) {
    if (done) return
    done = true
    onRejected(ex)
  }
}

function resolve(result) {
  try {
     var then = getThen(result);
     if (then) {
        doResolve(then.bind(result), resolve, reject)
        return
     }
      fulfill(result);
    } catch (e) {
      reject(e);
    }
}

doResolve(fn, resolve, reject);

訂閱

this.then = function (onFulfilled, onRejected) {
  var self = this;
  return new Promise(function (resolve, reject) {
    return self.done(function (result) {
      if (typeof onFulfilled === 'function') {
        try {
          return resolve(onFulfilled(result));
        } catch (ex) {
          return reject(ex);
        }
      } else {
        return resolve(result);
      }
    }, function (error) {
      if (typeof onRejected === 'function') {
        try {
          return resolve(onRejected(error));
        } catch (ex) {
          return reject(ex);
        }
      } else {
        return reject(error);
      }
    });
  });
}