Promise

构造函数

new Promise((resolve, reject) => {
  // ...
})

状态

• padding

  • 初始状态
  • 可以转换为 fulfilled 或 rejected

• fulfilled

  • 最终态，不可变
  • 执行 resolve 事件，状态变为 fulfilled，执行 onFulfilled 函数

• rejected

  • 最终态，不可变
  • 执行 reject 事件，状态变为 rejected，执行 onRejected 函数

静态方法

Promise.resolve

Promise.resolve 方法可以认为是 new Promise() 方法的语法糖

Promise.resolve(42)
// 等同于
new Promise(function (resolve) {
  resolve(42)
})

Promise.reject

Promise.reject 方法可以认为是 new Promise() 方法的语法糖

Promise.reject(42)
// 等同于
new Promise(function (resolve, reject) {
  reject(42)
})

Promise.then

promise.then(onFulfilled, onRejected)

• 回调函数异步执行

  onFulfilled 和 onRejected 是微任务`

• onFulfilled 和 onRejected 只能是函数，如果不是函数，会被忽略

Promise.resolve('foo')
  .then(Promise.resolve('bar'))
  .then(function (result) {
    console.log(result)
  }) // 'foo'

• 返回值是一个新的 Promise 对象

const p1 = new Promise((resolve, reject) => {
  resolve('foo')
})
const p2 = p1.then((value) => {
  console.log(value)
})
const p3 = p2.catch((error) => {
  console.log(error)
})
console.log(p1 === p2) // false
console.log(p2 === p3) // false

Promise.catch

• Promise.catch 只是 promise.then(undefined, onRejected)方法的语法糖

Promise.resolve()
  .then((data) => console.log(data))
  .catch((err) => console.log(err))
// 相当于
Promise.resolve()
  .then((data) => console.log(data))
  .then(undefined, (err) => console.log(err))

• catch 函数在同一个时间点只属于某一个 Promise

let p1 = new Promise((resolve, reject) => {
  // 第一层具体执行逻辑
  resolve(1) // Promise(1)
})
  .then((res) => {
    // 第二层具体执行逻辑
    return 2 // Promise(2)
  })
  .then((res) => {
    // 第三层具体执行逻辑
    return 3 // Promise(3)
  })
  .catch((err) => {
    console.log(err)
  })

如果第一层具体执行逻辑中出现错误，那么 p1 就会进入 catch 函数，而不会进入第二层具体执行逻辑，也不会进入第三层具体执 行逻辑

如果第二层具体执行逻辑中出现错误，那么 p1 就会进入 catch 函数，而不会进入第三层具体执行逻辑

如果第三层具体执行逻辑中出现错误，那么 p1 就会进入 catch 函数

Promise.all

Promise.all 方法用于将多个 Promise 实例，包装成一个新的 Promise 实例

const p = Promise.all([p1, p2, p3])

p 的状态由 p1、p2、p3 决定，分成两种情况

• 只有 p1、p2、p3 的状态都变成 fulfilled，p 的状态才会变成 fulfilled，此时 p1、p2、p3 的返回值组成一个 数组，传递给 p 的回调函数
• 只要 p1、p2、p3 之中有一个被 rejected，p 的状态就变成 rejected，此时第一个被 reject 的实例的返回值，会传 递给 p 的回调函数

Promise.race

• Promise.race 只要有一个 promise 对象进入 FulFilled 或者 Rejected 状态的话，就会继续进行后面的处理
• 和 Promise.all 一样是所有数组当中的 Promise 是同时并行的
• Promise.race 在第一个 promise 对象变为 Fulfilled 之后，并不会取消其他 promise 对象的执行