如何實現Promise.all

這篇文章主要介紹“如何實現Promise.all”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“如何實現Promise.all”文章能幫助大家解決問題。

Promise.resolve

簡要回顧

• Promise.resolve(value) 方法返回一個以給定值解析后的Promise 對象。

• 如果這個值是一個 promise ，那么將返回這個 promise ；

• 如果這個值是thenable（即帶有"then" 方法），返回的promise會“跟隨”這個thenable的對象，采用它的最終狀態；否則返回的promise將以此值完成。

這是MDN上的解釋，我們挨個看一下

• Promise.resolve最終結果還是一個Promise，并且與Promise.resolve(該值)傳入的值息息相關

• 傳入的參數可以是一個Promise實例，那么該函數執行的結果是直接將實例返回

• 這里最主要需要理解跟隨，可以理解成Promise最終狀態就是這個thenable對象輸出的值

小例子

// 1. 非Promise對象，非thenable對象
Promise.resolve(1).then(console.log) // 1
// 2. Promise對象成功狀態
const p2 = new Promise((resolve) => resolve(2))
Promise.resolve(p2).then(console.log) // 2
// 3. Promise對象失敗狀態
const p3 = new Promise((_, reject) => reject('err3'))
Promise.resolve(p3).catch(console.error) // err3
// 4. thenable對象
const p4 = {
  then (resolve) {
    setTimeout(() => resolve(4), 1000)
  }
}
Promise.resolve(p4).then(console.log) // 4
// 5. 啥都沒傳
Promise.resolve().then(console.log) // undefined

源碼實現

Promise.myResolve = function (value) {
  // 是Promise實例，直接返回即可
  if (value && typeof value === 'object' && (value instanceof Promise)) {
    return value
  }
  // 否則其他情況一律再通過Promise包裝一下 
  return new Promise((resolve) => {
    resolve(value)
  })
}
// 測試一下，還是用剛才的例子
// 1. 非Promise對象，非thenable對象
Promise.myResolve(1).then(console.log) // 1
// 2. Promise對象成功狀態
const p2 = new Promise((resolve) => resolve(2))
Promise.myResolve(p2).then(console.log) // 2
// 3. Promise對象失敗狀態
const p3 = new Promise((_, reject) => reject('err3'))
Promise.myResolve(p3).catch(console.error) // err3
// 4. thenable對象
const p4 = {
  then (resolve) {
    setTimeout(() => resolve(4), 1000)
  }
}
Promise.myResolve(p4).then(console.log) // 4
// 5. 啥都沒傳
Promise.myResolve().then(console.log) // undefined

疑問

從源碼實現中，并沒有看到對于thenable對象的特殊處理呀！其實確實也不需要在Promise.resolve中處理，真實處理的地方應該是在Promise構造函數中，如果你對這塊感興趣，馬上就會寫Promise的實現篇，期待你的閱讀噢。

Promise.reject

簡要回顧

Promise.reject() 方法返回一個帶有拒絕原因的Promise對象。

Promise.reject(new Error('fail'))
  .then(() => console.log('Resolved'), 
        (err) => console.log('Rejected', err))
// 輸出以下內容        
// Rejected Error: fail
//    at <anonymous>:2:16

源碼實現

reject實現相對簡單，只要返回一個新的Promise，并且將結果狀態設置為拒絕就可以

Promise.myReject = function (value) {
  return new Promise((_, reject) => {
    reject(value)
  })
}
// 測試一下
Promise.myReject(new Error('fail'))
  .then(() => console.log('Resolved'), 
        (err) => console.log('Rejected', err))
// Rejected Error: fail
//    at <anonymous>:9:18

Promise.all

簡要回顧

Promise.all()方法用于將多個 Promise 實例，包裝成一個新的 Promise 實例。這個靜態方法應該是面試中最常見的啦

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

最終p的狀態由p1、p2、p3決定，分成兩種情況。

（1）只有p1、p2、p3的狀態都變成fulfilled，p的狀態才會變成fulfilled，此時p1、p2、p3的返回值組成一個數組，傳遞給p的回調函數。

（2）只要p1、p2、p3之中有一個被rejected，p的狀態就變成rejected，此時第一個被reject的實例的返回值，會傳遞給p的回調函數。

const p1 = Promise.resolve(1)
const p2 = new Promise((resolve) => {
  setTimeout(() => resolve(2), 1000)
})
const p3 = new Promise((resolve) => {
  setTimeout(() => resolve(3), 3000)
})
const p4 = Promise.reject('err4')
const p5 = Promise.reject('err5')
// 1. 所有的Promise都成功了
const p11 = Promise.all([ p1, p2, p3 ])
	.then(console.log) // [ 1, 2, 3 ]
      .catch(console.log)
// 2. 有一個Promise失敗了
const p12 = Promise.all([ p1, p2, p4 ])
	.then(console.log)
      .catch(console.log) // err4
// 3. 有兩個Promise失敗了，可以看到最終輸出的是err4，第一個失敗的返回值
const p13 = Promise.all([ p1, p4, p5 ])
	.then(console.log)
      .catch(console.log) // err4

源碼實現

Promise.myAll = (promises) => {
  return new Promise((rs, rj) => {
    // 計數器
    let count = 0
    // 存放結果
    let result = []
    const len = promises.length
    if (len === 0) {
      return rs([])
    }
    promises.forEach((p, i) => {
      // 注意有的數組項有可能不是Promise，需要手動轉化一下
      Promise.resolve(p).then((res) => {
        count += 1
        // 收集每個Promise的返回值 
        result[ i ] = res
        // 當所有的Promise都成功了，那么將返回的Promise結果設置為result
        if (count === len) {
          rs(result)
        }
        // 監聽數組項中的Promise catch只要有一個失敗，那么我們自己返回的Promise也會失敗
      }).catch(rj)
    })
  })
}
// 測試一下
const p1 = Promise.resolve(1)
const p2 = new Promise((resolve) => {
  setTimeout(() => resolve(2), 1000)
})
const p3 = new Promise((resolve) => {
  setTimeout(() => resolve(3), 3000)
})
const p4 = Promise.reject('err4')
const p5 = Promise.reject('err5')
// 1. 所有的Promise都成功了
const p11 = Promise.myAll([ p1, p2, p3 ])
	.then(console.log) // [ 1, 2, 3 ]
      .catch(console.log)
// 2. 有一個Promise失敗了
const p12 = Promise.myAll([ p1, p2, p4 ])
	.then(console.log)
      .catch(console.log) // err4
// 3. 有兩個Promise失敗了，可以看到最終輸出的是err4，第一個失敗的返回值
const p13 = Promise.myAll([ p1, p4, p5 ])
	.then(console.log)
      .catch(console.log) // err4
// 與原生的Promise.all返回是一致的

Promise.allSettled

簡要回顧

有時候，我們希望等到一組異步操作都結束了，不管每一個操作是成功還是失敗，再進行下一步操作。顯然Promise.all(其只要是一個失敗了，結果即進入失敗狀態)不太適合，所以有了Promise.allSettled

Promise.allSettled()方法接受一個數組作為參數，數組的每個成員都是一個 Promise 對象，并返回一個新的 Promise 對象。只有等到參數數組的所有 Promise 對象都發生狀態變更（不管是fulfilled還是rejected），返回的 Promise 對象才會發生狀態變更,一旦發生狀態變更，狀態總是fulfilled，不會變成rejected

還是以上面的例子為例， 我們看看與Promise.all有什么不同

const p1 = Promise.resolve(1)
const p2 = new Promise((resolve) => {
  setTimeout(() => resolve(2), 1000)
})
const p3 = new Promise((resolve) => {
  setTimeout(() => resolve(3), 3000)
})
const p4 = Promise.reject('err4')
const p5 = Promise.reject('err5')
// 1. 所有的Promise都成功了
const p11 = Promise.allSettled([ p1, p2, p3 ])
	.then((res) => console.log(JSON.stringify(res, null,  2)))
// 輸出 
/*
[
  {
    "status": "fulfilled",
    "value": 1
  },
  {
    "status": "fulfilled",
    "value": 2
  },
  {
    "status": "fulfilled",
    "value": 3
  }
]
*/
// 2. 有一個Promise失敗了
const p12 = Promise.allSettled([ p1, p2, p4 ])
	.then((res) => console.log(JSON.stringify(res, null,  2)))
// 輸出 
/*
[
  {
    "status": "fulfilled",
    "value": 1
  },
  {
    "status": "fulfilled",
    "value": 2
  },
  {
    "status": "rejected",
    "reason": "err4"
  }
]
*/
// 3. 有兩個Promise失敗了
const p13 = Promise.allSettled([ p1, p4, p5 ])
	.then((res) => console.log(JSON.stringify(res, null,  2)))
// 輸出 
/*
[
  {
    "status": "fulfilled",
    "value": 1
  },
  {
    "status": "rejected",
    "reason": "err4"
  },
  {
    "status": "rejected",
    "reason": "err5"
  }
]
*/

可以看到：

• 不管是全部成功還是有部分失敗，最終都會進入Promise.allSettled的.then回調中

• 最后的返回值中，成功和失敗的項都有status屬性，成功時值是fulfilled，失敗時是rejected

• 最后的返回值中，成功含有value屬性，而失敗則是reason屬性

源碼實現

Promise.myAllSettled = (promises) => {
  return new Promise((rs, rj) => {
    let count = 0
    let result = []
    const len = promises.length
    // 數組是空的話，直接返回空數據
    if (len === 0) {
      return rs([])
    }
    promises.forEach((p, i) => {
      Promise.resolve(p).then((res) => {
        count += 1
        // 成功屬性設置 
        result[ i ] = {
          status: 'fulfilled',
          value: res
        }
        if (count === len) {
          rs(result)
        }
      }).catch((err) => {
        count += 1
        // 失敗屬性設置 
        result[i] = { 
          status: 'rejected', 
          reason: err 
        }
        if (count === len) {
          rs(result)
        }
      })
    })
  })
}
// 測試一下
const p1 = Promise.resolve(1)
const p2 = new Promise((resolve) => {
  setTimeout(() => resolve(2), 1000)
})
const p3 = new Promise((resolve) => {
  setTimeout(() => resolve(3), 3000)
})
const p4 = Promise.reject('err4')
const p5 = Promise.reject('err5')
// 1. 所有的Promise都成功了
const p11 = Promise.myAllSettled([ p1, p2, p3 ])
	.then((res) => console.log(JSON.stringify(res, null,  2)))
// 輸出 
/*
[
  {
    "status": "fulfilled",
    "value": 1
  },
  {
    "status": "fulfilled",
    "value": 2
  },
  {
    "status": "fulfilled",
    "value": 3
  }
]
*/
// 2. 有一個Promise失敗了
const p12 = Promise.myAllSettled([ p1, p2, p4 ])
	.then((res) => console.log(JSON.stringify(res, null,  2)))
// 輸出 
/*
[
  {
    "status": "fulfilled",
    "value": 1
  },
  {
    "status": "fulfilled",
    "value": 2
  },
  {
    "status": "rejected",
    "reason": "err4"
  }
]
*/
// 3. 有兩個Promise失敗了
const p13 = Promise.myAllSettled([ p1, p4, p5 ])
	.then((res) => console.log(JSON.stringify(res, null,  2)))
// 輸出 
/*
[
  {
    "status": "fulfilled",
    "value": 1
  },
  {
    "status": "rejected",
    "reason": "err4"
  },
  {
    "status": "rejected",
    "reason": "err5"
  }
]
*/

Promise.race

簡單回顧

Promise.race()方法同樣是將多個 Promise 實例，包裝成一個新的 Promise 實例。

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

只要p1、p2、p3之中有一個實例率先改變狀態，p的狀態就跟著改變。那個率先改變的 Promise 實例的返回值，就傳遞給p的回調函數。

const p1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, 1)
})
const p2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 2)
})
Promise.race([p1, p2]).then((value) => {
  console.log(value) // 2
})
Promise.race([p1, p2, 3]).then((value) => {
  console.log(value) // 3
})

源碼實現

聰明的你一定馬上知道該怎么實現了，只要了解哪個實例先改變了，那么Promise.race就跟隨這個結果，那么就可以寫出以下代碼

Promise.myRace = (promises) => {
  return new Promise((rs, rj) => {
    promises.forEach((p) => {
      // 對p進行一次包裝，防止非Promise對象
      // 并且對齊進行監聽，將我們自己返回的Promise的resolve，reject傳遞給p，哪個先改變狀態，我們返回的Promise也將會是什么狀態
      Promise.resolve(p).then(rs).catch(rj)
    })
  })
}
// 測試一下
const p1 = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, 1)
})
const p2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 2)
})
Promise.myRace([p1, p2]).then((value) => {
  console.log(value) // 2
})
Promise.myRace([p1, p2, 3]).then((value) => {
  console.log(value) // 3
})

關于“如何實現Promise.all”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。