promise 简单实现

参考 Promise A+ 简单实现 promise,用的setTimeout 模拟的异步，与实际浏览器Promise 有出入（具体可以看Event loop 相关），本文只做思路理解参考。

Promise 的简单实现，主要理解规范，也可以再理解一下几个点方变记忆：

• Promise的三种状态（pending，fulfilled，rejected）, pending状态转移后不可变
• resolve , resolve a promise with a promise
• reject
• Promise.prototype.then 返回一个新的promise 对象（链式操作）
• thenable对象

 1.简单实现

 

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

function needResolve() {
  throw new TypeError('need pass function to Promise')
}

function needuseNew() {
  throw new TypeError(
    'Promise is a constructor and should be called with the `new` keyword'
  )
}

function Promise(task) {
  var self = this
  this.state = PENDING
  this.value
  this.fulArr = []
  this.rejArr = []

  function resolve(value) {
    if (value != null && value.then && typeof value.then == 'function') {
      return value.then(resolve, reject)
    }
    setTimeout(() => {
      if (self.state == PENDING) {
        self.state = FULFILLED
        self.value = value
        self.fulArr.forEach(item => {
          item(self.value)
        })
      }
    })
  }

  function reject(reason) {
    setTimeout(() => {
      if (self.state == PENDING) {
        self.state = REJECTED
        self.value = reason
        self.fulArr.forEach(item => {
          item(self.value)
        })
      }
    })
  }
  typeof task !== 'function' && needResolve()
  !(this instanceof Promise) && needResolve()
  try {
    task(
      function(value) {
        resolve(value)
      },
      function(reason) {
        reject(reason)
      }
    )
  } catch (e) {
    reject(e)
  }
}

function resolvePromise(promise, x, resolve, reject) {
  if (promise === x) {
    return reject(new TypeError('do not resolve promise with itself'))
  }
  var then, called
  // resolve promise with promise
  if (x instanceof Promise) {
    if (x.status == PENDING) {
      x.then(function(y) {
        resolvePromise(promise, y, resolve, reject)
      }, reject)
    } else {
      x.then(resolve, reject)
    }
    // thenable 其它的then
  } else if (x !== null && (typeof x == 'function' || typeof x == 'object')) {
    try {
      // resolve promise with promise
      then = x.then
      if (typeof then === 'function') {
        then.call(
          x,
          function(y) {
            if (called) {
              return
            }
            called = true
            resolvePromise(promise, y, resolve, reject)
          },
          function(r) {
            if (called) {
              return
            }
            called = true
            reject(r)
          }
        )
      } else {
        resolve(x)
      }
    } catch (e) {
      if (called) {
        return
      }
      called = true
      reject(e)
    }
  } else {
    resolve(x)
  }
}
Promise.prototype.then = function(onFulfilled, onRejected) {
  var self = this
  onFulfilled =
    typeof onFulfilled === 'function'
      ? onFulfilled
      : function(value) {
          return value
        }
  onRejected =
    typeof onRejected === 'function'
      ? onRejected
      : function(reason) {
          throw reason
        }
  var promise2
  if (self.state == PENDING) {
    promise2 = new Promise(function(resolve, reject) {
      self.fulArr.push(value => {
        try {
          let x = onFulfilled(value)
          resolvePromise(promise2, x, resolve, reject)
        } catch (e) {
          reject(e)
        }
      })
      self.reject.push(reason => {
        try {
          let x = onRejected(reason)
          resolvePromise(promise2, x, resolve, reject)
        } catch (e) {
          reject(e)
        }
      })
    })
  }
  if (self.state == FULFILLED) {
    promise2 = new Promise(function(resolve, reject) {
      setTimeout(() => {
        try {
          let x = onFulfilled(self.value)
          resolvePromise(promise2, x, resolve, reject)
        } catch (e) {
          reject(e)
        }
      })
    })
  }
  if (self.state == REJECTED) {
    promise2 = new Promise(function(resolve, reject) {
      setTimeout(() => {
        try {
          let x = onRejected(self.value)
          resolvePromise(promise2, x, resolve, reject)
        } catch (e) {
          reject(e)
        }
      })
    })
  }
  // then 必须返回一个新的promise
  return promise2
}

Promise.prototype.catch = function(onRejected) {
  return this.then(null, onRejected)
}

Promise.resolve = function(value) {
  return new Promise((resolve, reject) => {
    resolve(value)
  })
}
Promise.reject = function(value) {
  return new Promise((resolve, reject) => {
    reject(value)
  })
}

function gen(time, resolve) {
  let result = []
  let i = 0
  return function(index, value) {
    if (i < time) {
      i++
      result[index] = value
    } else {
      resolve(result)
    }
  }
}

Promise.race = function(arr) {
  return new Promise((resolve, reject) => {
    for (let i = 0; i < arr.length; i++) {
      Promise.resolve(arr[i]).then(resolve, reject)
    }
  })
}
Promise.all = function(arr) {
  return new Promise((resolve, reject) => {
    let done = gen(arr.length, resolve)
    for (let i = 0; i < arr.length; i++) {
      Promise.resolve(arr[i]).then(function(value) {
        done(value, i)
      }, reject)
    }
  })
}
module.exports = Promise