Promise 完全解析

class Promise {
  constructor(resolver) {
    if (typeof resolver !== 'function') {
      throw new TypeError('resolver must be a function')
    }

    this._state = internal.PENDING
    this._value = undefined

    // 代表不是由 Promise 内部创建，由用户调用
    if (resolver !== internal.noop) {
      safelyResolveThenable(this, resolver)
    }
  }
}

function safelyResolveThenable(self, resolver) {
  let called = false // 标记该promise是否被调用过
  function onError(value) {
    if (called) {
      return
    }
    called = true
    reject(self, value)
  }

  function onSuccess(value) {
    if (called) {
      return
    }
    called = true
    resolve(self, value)
  }

  function tryToUnwrap() {
    resolver(onSuccess, onError)
  }

  const result = tryCatch(tryToUnwrap)
  if (result.status === 'error') {
    onError(result.value)
  }
}

// ver 1.0
const resolve = function (self, value) {
  const result = tryCatch(getThen, value) // 通过 try..catch 执行 then(onFulfilled(value), onRejected(value))
  if (result.status === 'error') {
    return reject(self, result.value)
  }
  const thenable = result.value
  if (thenable) {
    safelyResolveThenable(self, value)
  } else {
    self._state = FULFILLED
    self._value = value
  }
  return self
}

const reject = function (self, error) {
  self._state = REJECTED
  self._value = error
  return self
}

const isPromise = promise => {
  return (
    promise &&
    (typeof promise === 'object' || typeof promise === 'function') &&
    typeof promise.then === 'function'
  )
}

function then(onFulfilled, onRejected) {
  // 构造一个新的 promise 用于 then 返回新的 Promise 实例
  const _promise = new this.constructor(internal.noop)
  if (this._state !== PENDING) {
    // 根据非 pending 状态决定回调策略
    const handler = this._state === FULFILLED ? onFulfilled : onRejected
    // unwrap 是异步执行方法，稍后介绍
    internal.unwrap(_promise, handler, this._value)
  } else {
    // 如果是 pending 状态，将 then 携带的方法添加到待执行队列中
    this._subscribers.push(new SubscriberItem(_promise, onFulfilled, onRejected))
  }
  return _promise
}

class SubscriberItem {
  constructor(promise, onFulfilled, onRejected) {
    this.promise = promise

    if (utils.isFunction(onFulfilled)) {
      this.onFulfilled = onFulfilled
      this.callFulfilled = this.otherCallFulfilled
    }
    if (utils.isFunction(onRejected)) {
      this.onRejected = onRejected
      this.callRejected = this.otherCallRejected
    }
  }

  callFulfilled(value) {
    internal.resolve(this.promise, value)
  }

  otherCallFulfilled(value) {
    internal.unwrap(this.promise, this.onFulfilled, value)
  }

  callRejected(value) {
    internal.reject(this.promise, value)
  }

  otherCallRejected(value) {
    internal.unwrap(this.promise, this.onRejected, value)
  }
}

// 在 resolve/reject 中添加调用 待执行队列 中方法的实现
const resolve = function (self, value) {
  // ...ver 1.0

  // 如果 then 成功且有返回值
  const thenable = result.value

  if (thenable) {
    safelyResolveThenable(self, thenable)
  } else {
    let i = 0
    const len = self._subscribers.length
    while (i < len) {
      self._subscribers[i].callFulfilled(value)
      i++
    }
  }
  // ...
}

const reject = function (self, error) {
  // ...

  let i = 0
  const length_ = self._subscribers.length
  while (i < length_) {
    self._subscribers[i].callRejected(error)
    i++
  }
  return self
}

/**
 * promise: promise 上下文实例
 * func: 根据状态传入 onFulfilled / onRejected 方法
 * value: 给func方法的值参数
 *
 */
function unwrap(promise, func, value) {
  // 需要环境支持 immediate 或 使用 setTimeout 降级
  immediate(function () {
    let returnValue
    try {
      returnValue = func(value) // 对当前 then 中的值调用 resolver 方法获得 returnValue
    } catch (error) {
      return reject(promise, error)
    }

    // 如果返回值 与 promise 一样，则说明 promise 返回了自身，不允许返回自身所以报错
    if (returnValue === promise) {
      reject(promise, new TypeError('Cannot resolve promise with itself'))
    } else {
      resolve(promise, returnValue)
    }
  })
}

class Promise {
  // ...

  catch(onRejected) {
    return this.then(null, onRejected)
  }

  finally(callback) {
    if (typeof callback !== 'function') {
      return this
    }

    const constructor = this.constructor

    return this.then(
      function (value) {
        // 这段代码是为了满足标准设计，对于 finally 返回的 promise , Promise.resolve(promise) 仍然会把finally 上一次的 then 结果带过来
        return constructor.resolve(callback()).then(function () {
          return value
        })
      },
      function (reason) {
        // 同理 抛出错误
        return constructor.resolve(callback()).then(function () {
          throw reason
        })
      },
    )
  }
}

Promise.resolve = function (value) {
  const Constructor = this
  if (value && typeof value === 'object' && value.constructor === Constructor) {
    return value
  }
  const promise = new Constructor(internal.noop)
  return resolve(promise, value)
}

Promise.reject = function (reason) {
  const Constructor = this
  const promise = new Constructor(internal.noop)
  return reject(promise, reason)
}

Promise.all = function (iterable) {
  const self = this
  // 如果参数不是数组则抛错
  if (!utils.isArray(iterable)) {
    return this.reject(new TypeError('parameter must be an array'))
  }

  const len = iterable.length

  let called = false
  // 如果参数长度为0 则说明为空数组
  if (!len) {
    return this.resolve([])
  }

  const values = new Array(len) // 最后输出的值
  let resolved = 0 // resolve 的数量
  let i = 0
  const promise = new this(internal.noop)

  function allResolver(value, i) {
    self.resolve(value).then(
      function (value) {
        values[i] = value
        if (++resolved === len && !called) {
          called = true
          internal.resolve(promise, values)
        }
      },
      function (error) {
        if (!called) {
          called = true
          internal.reject(promise, error)
        }
      },
    )
  }

  while (i++ < len) {
    allResolver(iterable[i], i)
  }
  return promise
}

function allSettled(iterable) {
  const self = this

  if (!utils.isArray(iterable)) {
    return this.reject(new TypeError('parameter must be an array'))
  }

  const len = iterable.length

  let called = false
  if (!len) {
    return this.resolve([])
  }

  const values = new Array(len) // 最后输出的值
  let settled = 0 // resolve 的数量
  let i = 0
  const promise = new this(internal.noop)

  function allResolver(value, i) {
    self.resolve(value).then(
      function (value) {
        values[i] = {
          status: 'fulfilled',
          value,
        }
        if (++settled === len && !called) {
          called = true
          internal.resolve(promise, values)
        }
      },
      function (reason) {
        values[i] = {
          status: 'rejected',
          reason,
        }
        if (++settled === len && !called) {
          called = true
          internal.resolve(promise, values)
        }
      },
    )
  }

  while (i++ < len) {
    allResolver(iterable[i], i)
  }
  return promise
}

Promise.race = function (iterable) {
  const self = this
  if (!utils.isArray(iterable)) {
    return this.reject(new TypeError('parameter must be an array'))
  }

  const len = iterable.length

  let called = false
  if (!len) {
    return this.resolve([])
  }

  let i = 0
  const promise = new this(internal.noop)

  function resolver(value) {
    self.resolve(value).then(
      function (value) {
        if (!called) {
          called = true
          internal.resolve(promise, value)
        }
      },
      function (error) {
        if (!called) {
          called = true
          internal.reject(promise, error)
        }
      },
    )
  }

  while (i++ < len) {
    resolver(iterable[i])
  }
  return promise
}