1. "use strict"
    2. /* 工具类方法 */
    3. var def = function def(obj, key, value) {
    4.   Object.defineProperty(obj, key, {
    5.     value,
    6.     writable: true,
    7.     configurable: true,
    8.     enumerable: false
    9.   })
    10. }
    12. /* Promise核心代码 */
    13. function Promise(executor) {
    14.   var self = this
    15.   if (!(self instanceof Promise)) throw new TypeError("Promise constructor cannot be invoked without 'new'")
    16.   if (typeof executor !== "function") throw new TypeError("Promise resolver is not a function")
    17.   // 给实例设置私有属性「状态 & 值」
    18.   def(self, 'state', 'pending')
    19.   def(self, 'result', undefined)
    20.   def(self, 'onfulfilledCallback', [])
    21.   def(self, 'onrejectedCallback', [])
    22.   // 修改实例状态和值的方法
    23.   var change = function change(state, result) {
    24.     if (self.state !== "pending") return
    25.     self.state = state
    26.     self.result = result
    27.     // 状态修改完毕，要把之前存储的onfulfilled/onrejected执行
    28.     var callbacks = state === 'fulfilled' ? self.onfulfilledCallback : self.onrejectedCallback
    29.     setTimeout(function () {
    30.       callbacks.forEach(function (callback) {
    31.         callback(self.result)
    32.       })
    33.     })
    34.   }
    35.   // 立即执行 executor 函数
    36.   try {
    37.     executor(
    38.       function resolve(value) {
    39.         change('fulfilled', value)
    40.       },
    41.       function reject(reason) {
    42.         change('rejected', reason)
    43.       }
    44.     )
    45.   } catch (err) {
    46.     // 如果 executor 函数执行报错了，则修改实例状态是失败，值是报错的原因
    47.     change('rejected', err)
    48.   }
    49. }
    51. /* Promise.prototype */
    52. var proto = Promise.prototype
    53. def(proto, "then", function then(onfulfilled, onrejected) {
    54.   var self = this
    55.   if (!(self instanceof Promise)) throw new TypeError("Method Promise.prototype.then called on incompatible receiver #<Promise>")
    56.   // 根据现有实例的状态，做不同的处理
    57.   switch (self.state) {
    58.     case 'fulfilled':
    59.       setTimeout(function () {
    60.         onfulfilled(self.result)
    61.       })
    62.       break
    63.     case 'rejected':
    64.       setTimeout(function () {
    65.         onrejected(self.result)
    66.       })
    67.       break
    68.     default:
    69.       self.onfulfilledCallback.push(onfulfilled)
    70.       self.onrejectedCallback.push(onrejected)
    71.   }
    72. })
    74. /* static Promise */
    75. def(Promise, "all", function all(promises) {
    76.   // 确保promises是一个数组「内置all方法：要求promises必须具备迭代器规范」
    77.   if (!Array.isArray(promises)) throw new TypeError("promises is not a array")
    78.   // 返回一个总的实例
    79.   return new Promise(function (resolve, reject) {
    80.     var count = 0,
    81.       len = promises.length,
    82.       values = []
    83.     // 迭代promises集合中的每一项，根据每一项的状态和值，来决定总实例的状态和值
    84.     for (var i = 0; i < len; i++) {
    85.       (function (i) {
    86.         var promise = promises[i]
    87.         // 如果循环这一项不是实例，则把其变为状态是成功，值是本身的实例
    88.         if (!(promise instanceof Promise)) promise = Promise.resolve(promise)
    89.         promise
    90.           .then(function (value) {
    91.             // 只要有一项是成功的，则计数器累加
    92.             count++
    93.             values[i] = value
    94.             // 等待所有项都成功，总实例才是成功的
    95.             if (count >= len) resolve(values)
    96.           })
    97.           .catch(function (reason) {
    98.             // 只要有一项是失败的，则总实例就是失败的，值就是失败项的值
    99.             reject(reason)
    100.           })
    101.       })(i);
    102.     }
    103.   })
    104. })

    J37H$IAVILJ7R7[SU56KY]5_tmb.jpg![P]RRD70)WCV]Y4%7663EI4.jpg