国产成人精品视频免费看,人人操,人人爱黄色,亚洲欧美性爱图片,日韩成人电影在线免费,91超碰影院青青草人人,五月天淫香淫色,久久精品在,日本艹逼网站

作者：前端胖頭魚

來源：SegmentFault 思否社區(qū)

前言

(?﹏?)曾經(jīng)真實發(fā)生在一個朋友身上的真實事件，面試官讓他手寫一個Promise.all，朋友現(xiàn)場發(fā)揮不太好，沒有寫出來，事后他追問面試官給的模糊評價是基礎不夠扎實，原理性知識掌握較少... 當然整場面試失利，并不僅僅是這一個題目，肯定還有其他方面的原因。

但是卻給我們敲響一個警鐘：Promise手寫實現(xiàn)、Promise靜態(tài)方法實現(xiàn)早已經(jīng)是面試中的高頻考題，如果你對其還不甚了解，耽誤你10分鐘，我們一起干到他懂O(∩_∩)O

Promise.resolve

簡要回顧

Promise.resolve(value) 方法返回一個以給定值解析后的 Promise 對象。
如果這個值是一個 promise ，那么將返回這個 promise ；
如果這個值是thenable（即帶有 "then" 方法），返回的promise會“跟隨”這個thenable的對象，采用它的最終狀態(tài)；否則返回的promise將以此值完成。

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

Promise.resolve最終結果還是一個Promise，并且與Promise.resolve(該值)傳入的值息息相關
傳入的參數(shù)可以是一個Promise實例，那么該函數(shù)執(zhí)行的結果是直接將實例返回
這里最主要需要理解跟隨，可以理解成Promise最終狀態(tài)就是這個thenable對象輸出的值

小例子

// 1. 非Promise對象，非thenable對象
Promise.resolve(1).then(console.log) // 1

// 2. Promise對象成功狀態(tài)
const p2 = new Promise((resolve) => resolve(2))

Promise.resolve(p2).then(console.log) // 2

// 3. Promise對象失敗狀態(tài)
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

源碼實現(xiàn)

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對象成功狀態(tài)
const p2 = new Promise((resolve) => resolve(2))

Promise.myResolve(p2).then(console.log) // 2

// 3. Promise對象失敗狀態(tài)
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

疑問

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

Promise.reject

簡要回顧

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

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

源碼實現(xiàn)

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

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 實例。這個靜態(tài)方法應該是面試中最常見的啦

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

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

（1）只有p1、p2、p3的狀態(tài)都變成fulfilled，p的狀態(tài)才會變成fulfilled，此時p1、p2、p3的返回值組成一個數(shù)組，傳遞給p的回調(diào)函數(shù)。

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

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

源碼實現(xiàn)

Promise.myAll = (promises) => {
  return new Promise((rs, rj) => {
    // 計數(shù)器
    let count = 0
    // 存放結果
    let result = []
    const len = promises.length
    
    if (len === 0) {
      return rs([])
    }
    
    promises.forEach((p, i) => {
      // 注意有的數(shù)組項有可能不是Promise，需要手動轉(zhuǎn)化一下
      Promise.resolve(p).then((res) => {
        count += 1
        // 收集每個Promise的返回值 
        result[ i ] = res
        // 當所有的Promise都成功了，那么將返回的Promise結果設置為result
        if (count === len) {
          rs(result)
        }
        // 監(jiān)聽數(shù)組項中的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(其只要是一個失敗了，結果即進入失敗狀態(tài))不太適合，所以有了Promise.allSettled

Promise.allSettled()方法接受一個數(shù)組作為參數(shù)，數(shù)組的每個成員都是一個 Promise 對象，并返回一個新的 Promise 對象。只有等到參數(shù)數(shù)組的所有 Promise 對象都發(fā)生狀態(tài)變更（不管是fulfilled還是rejected），返回的 Promise 對象才會發(fā)生狀態(tài)變更,一旦發(fā)生狀態(tài)變更，狀態(tài)總是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回調(diào)中
最后的返回值中，成功和失敗的項都有status屬性，成功時值是fulfilled，失敗時是rejected
最后的返回值中，成功含有value屬性，而失敗則是reason屬性

源碼實現(xiàn)

Promise.myAllSettled = (promises) => {
  return new Promise((rs, rj) => {
    let count = 0
    let result = []
    const len = promises.length
    // 數(shù)組是空的話，直接返回空數(shù)據(jù)
    if (len === 0) {
      return resolve([])
    }

    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之中有一個實例率先改變狀態(tài)，p的狀態(tài)就跟著改變。那個率先改變的 Promise 實例的返回值，就傳遞給p的回調(diào)函數(shù)。

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
})

源碼實現(xiàn)

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

Promise.myRace = (promises) => {
  return new Promise((rs, rj) => {
    promises.forEach((p) => {
      // 對p進行一次包裝，防止非Promise對象
      // 并且對齊進行監(jiān)聽，將我們自己返回的Promise的resolve，reject傳遞給p，哪個先改變狀態(tài)，我們返回的Promise也將會是什么狀態(tài)
      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
})

結尾

也許你我素未謀面，但很可能相見恨晚。希望這里能成為你的棲息之地，我愿和你一起收獲喜悅，奔赴成長。

以上就是第一篇手寫實現(xiàn)原理解析啦！歡迎大家指正其中可能存在的錯誤和問題

點擊左下角閱讀原文，到 SegmentFault 思否社區(qū) 和文章作者展開更多互動和交流，掃描下方”二維碼“或在“公眾號后臺“回復“ 入群 ”即可加入我們的技術交流群，收獲更多的技術文章~

- END -

因為實現(xiàn)不了Promise.all，一場面試涼涼了

前言

Promise.resolve

簡要回顧

源碼實現(xiàn)

Promise.reject

簡要回顧

源碼實現(xiàn)

Promise.all

簡要回顧

源碼實現(xiàn)

Promise.allSettled

簡要回顧

源碼實現(xiàn)

Promise.race

簡單回顧

源碼實現(xiàn)

結尾

因為實現(xiàn)不了Promise.all，一場面試涼涼了