MS: JS异步编程之Promise

var p = new Promise(function(resolve,reject){
    setTimeout(function(){
       resolve("success")
    },1000);
    console.log("创建一个新的promise");
})
p.then(function(x){
  console.log(x)
})

// 输出：创建一个新的promise
// 输出：success

var p = new Promise(function(resolve, reject) {
  resolve()
});
p.then(...).then(...).then(...)

const isFunction = variable => typeof variable === 'function'

// 定义三个常量表示状态
const PENDING = 'pending'
const FULFILLED = 'fulfilled',
const REJECTED = 'rejected'

class MyPromise {
  constructor(func) {
    this.onFulfilledArray = [] // 成功回调数组
    this.onRejectedArray = [] // 失败回调数组
    this.value = void 0
    this.reason = void 0
    this.status = PENDING
    func(this.resolve.bind(this), this.reject.bind(this))
  }
  resolve(val) {
    if (this.status !== PENDING) return
    const self = this
    const doResolve = () => {
      if (self.status === PENDING) {
        self.status = FULFILLED
        self.value = val
        // resolve里面将所有成功的回调拿出来执行
        while (self.onFulfilledArray.length) {
          const fn = self.onFulfilledArray.shift()
          fn()
        }
      }
    }
    setTimeout(doResolve(), 0)
  }
  reject(err) {
    if (this.status !== PENDING) return
    const self = this
    const doReject = () => {
      if (self.status === PENDING) {
        self.status = REJECTED
        self.reason = err
        // resolve里面将所有失败的回调拿出来执行
        self.onRejectedArray.forEach(fn => {
          fn()
        })
      }
    }
    setTimeout(doReject, 0)
  }
  then(onFulfilled, onRejected) {
    let nextPromise = void 0
    switch (this.status) {
      case PENDING:
        nextPromise = new MyPromise((resolve, reject) => {
          this.onFulfilledArray.push(() => {
            try {
              let res = onFulfilled(self.value)
              resolve(res)
            } catch (error) {
              reject(error)
            }
          })
          this.onRejectedArray.push(() => {
            try {
              let res = onRejected(self.reason)
              resolve(res)
            } catch (e) {
              reject(e)
            }
          })
        })
        break
      case FULFILLED:
        nextPromise = new MyPromise((resolve, reject) => {
          try {
            let res = onFulfilled(self.value)
            resolve(res)
          } catch (e) {
            reject(e)
          }
        })
        break
      case REJECTED:
        nextPromise = new MyPromise((resolve, reject) => {
          try {
            let res = onRejected(self.reason)
            resolve(res)
          } catch (e) {
            reject(e)
          }
        })
        onRejected(self.reason)
        break
    }
    return nextPromise
  }
  catch(err) {
    // 默认没有成功，只有失败
    return this.then(void 0, err)
  }
}

...
function resolvePromise(x, nextPromise, resolve, reject) {
  // 处理三种情况：
  // 1.循环引用
  // 2.x 为MyPromise
  // 3.x为基础类型
  if (x === nextPromise) {
    // x 和 nextPromise 指向同一对象，循环引用抛出错误。防止死循环
    return reject(new TypeError('循环引用'))
  } else if (x && (typeof x === 'object' || isFunction(x))) {
    // x 是对象或者函数
    let called = false // 避免多次调用
    try {
      let then = x.then // 判断对象是否有 then 方法
      if (isFunction(then)) {
        // then 是函数，就断定 x 是一个 MyPromise（根据Promise A+规范）
        then.call(
          x,
          function(y) {
            // 调用返回的MyPromise，用它的结果作为下一次then的结果
            if (called) return
            called = true
            resolvePromise(y, nextPromise, resolve, reject) // 递归解析成功后的值，直到它是一个普通值为止
          },
          function(r) {
            if (called) return
            called = true
            reject(r) // 取then时发生错误了
          }
        )
      } else {
        resolve(x) // 此时，x是一个普通对象
      }
    } catch (e) {
      reject(e)
    }
  } else {
    // x 是原始数据类型 / 没有返回值，这里即是undefined
    resolve(x)
  }
}
class MyPromise {
  constructor(func) {
    ...
  }
  ...
  then(onFulfilled, onRejected) {
    const self = this
    // 如果onFulfilled不是函数，给一个默认函数，返回value
    let realOnFulfilled = onFulfilled
    if (!isFunction(realOnFulfilled)) realOnFulfilled = value => value
    let realOnRejected = onRejected
    if (!isFunction(onRejected)) {
      realOnRejected = reason => {
        if (reason instanceof Error) {
          throw reason
        } else {
          throw new Error(reason)
        }
      }
    }
    let nextPromise = void 0
    switch (this.status) {
      case PENDING:
        nextPromise = new MyPromise((resolve, reject) => {
          this.onFulfilledArray.push(() => {
            try {
              let res = realOnFulfilled(self.value)
              resolvePromise(res, nextPromise, resolve, reject)
              // resolve(res)
            } catch (error) {
              reject(error)
            }
            // onFulfilled(self.value)
          })
          this.onRejectedArray.push(() => {
            try {
              let res = realOnRejected(self.reason)
              resolve(res)
            } catch (e) {
              reject(e)
            }
            // onRejected(self.reason)
          })
        })
        break
      case FULFILLED:
        nextPromise = new MyPromise((resolve, reject) => {
          try {
            let res = realOnFulfilled(self.value)
            resolvePromise(res, nextPromise, resolve, reject)
          } catch (e) {
            reject(e)
          }
        })
        // onFulfilled(self.value)
        break
      case REJECTED:
        nextPromise = new MyPromise((resolve, reject) => {
          try {
            let res = realOnRejected(self.reason)
            resolvePromise(res, nextPromise, resolve, reject)
          } catch (e) {
            reject(e)
          }
        })
        onRejected(self.reason)
        break
    }
    return nextPromise
  }
  ...
}

MyPromise.prototype.finally = function(callback) {
  return this.then(
    data => {
      return MyPromise.resolve(callback()).then(() => data)
    },
    err => {
      return MyPromise.resolve(
        callback().then(() => {
          throw err
        })
      )
    }
  )
}

...
function isPromise(val) {
  return val && typeof val.then === 'function'
}
class MyPromise() {
  ...
}
...
MyPromise.all = function(promises) {
  if (!Array.isArray(promises)) {
    throw new Error('Not a array')
  }
  return new MyPromise((resolve, reject) => {
    let result = []
    let times = 0 // 计数器
    function processData(index, val) {
      result[index] = val
      if (++times === promises.length) {
        resolve(result)
      }
    }
    for (let i = 0; i < promises.length; i++) {
      let p = promises[i]
      if (isPromise(p)) {
        // MyPromise对象
        p.then(data => {
          processData(i, data)
        }, reject)
      } else {
        processData(i, p) // 普通值
      }
    }
  })
}

...
class MyPromise() {
  ...
}
...
MyPromise.race = function(promises) {
  if (!Array.isArray(promises)) {
    throw new Error('Not a array')
  }
  return new MyPromise((resolve, reject) => {
    if (promises.length === 0) {
      return
    } else {
      for (let p of promises) {
        p.then(
          value => {
            resolve(value)
          },
          reason => {
            reject(reason)
          }
        )
      }
    }
  })
}