手写一个符合promiseA+规范的promise
    872 passing (16s)

    1. const PENDING = 'pending'
    2. const FULLFILLED = 'fullfilled'
    3. const REJECTED = 'rejected'
    5. class PromiseOfMine {
    6.     constructor(executor) {
    7.         // 捕获执行器的异常
    8.         try {
    9.             executor(this.resolve, this.reject)
    10.         } catch (e) {
    11.             this.reject(e)
    12.         }
    13.     }
    15.     // promise的状态
    16.     status = PENDING
    18.     // 成功的值
    19.     value = undefined
    20.     // 失败的原因
    21.     reason = undefined
    23.     // 异步回调队列，用来放同一个promise多次then调用:p1.then(...); p1.then(...); p1.then(...);
    24.     successCallback = []
    25.     failCallback = []
    27.     // 改变状态，执行异步回调
    28.     resolve = (value) => {
    29.         if (this.status !== PENDING) return
    30.         this.status = FULLFILLED
    32.         this.value = value
    34.         while (this.successCallback.length) {
    35.             this.successCallback.shift()()
    36.         }
    37.     }
    39.     reject = (reason) => {
    40.         if (this.status !== PENDING) return
    41.         this.status = REJECTED
    43.         this.reason = reason
    45.         while (this.failCallback.length) {
    46.             this.failCallback.shift()()
    47.         }
    48.     }
    50.     // 判断状态，执行同步回调，如果是pending，就把异步回调存放起来，等到状态变更时触发
    51.     then = (successCallback, failCallback) => {
    52.         // 处理then没有参数的情况，把传过来的promise结果直接向后传递
    53.         successCallback = typeof successCallback == 'function' ? successCallback : value => value
    54.         failCallback = typeof failCallback == 'function' ? failCallback : reason => { throw reason }
    56.         // 返回一个新的promise实现then的链式调用
    57.         let newPromise = new PromiseOfMine((resolve, reject) => {
    59.             // 执行同步回调
    60.             if (this.status === FULLFILLED) {
    61.                 // setTimeout是为了保证resolvePromise变量已被声明
    62.                 setTimeout(() => {
    63.                     try {
    64.                         let x = successCallback(this.value)
    65.                         // 回调的结果x可能是一个普通值（没有返回值时是undefined），也可能是个promise，
    66.                         // 如果x是个普通值或者undefined，就直接resolve(x)传入新promise的then方法的成功回调
    67.                         // 如果x是个promise，就执行这个promise，判断这个promise的状态，根据状态调用resolve和reject
    68.                         resolvePromise(newPromise, x, resolve, reject)
    69.                     } catch (e) {
    70.                         reject(e)
    71.                     }
    72.                 }, 0)
    74.             } else if (this.status === REJECTED) {
    75.                 setTimeout(() => {
    76.                     try {
    77.                         let x = failCallback(this.reason)
    78.                         resolvePromise(newPromise, x, resolve, reject)
    79.                     } catch (e) {
    80.                         reject(e)
    81.                     }
    82.                 }, 0)
    83.             }
    85.             // 把异步回调放到异步回调数组中，状态改变后会立刻处理
    86.             else {
    87.                 this.successCallback.push(() => {
    88.                     setTimeout(() => {
    89.                         try {
    90.                             let x = successCallback(this.value)
    91.                             resolvePromise(newPromise, x, resolve, reject)
    92.                         } catch (e) {
    93.                             reject(e)
    94.                         }
    95.                     }, 0)
    96.                 })
    97.                 this.failCallback.push(() => {
    98.                     setTimeout(() => {
    99.                         try {
    100.                             let x = failCallback(this.reason)
    101.                             resolvePromise(newPromise, x, resolve, reject)
    102.                         } catch (e) {
    103.                             reject(e)
    104.                         }
    105.                     }, 0)
    106.                 })
    107.             }
    108.         })
    110.         return newPromise
    111.     }
    113.     finally = (callback) => {
    114.         return this.then(value => {
    115.             // callback可能是个promise对象，需要等到他执行完在return
    116.             return PromiseOfMine.resolve(callback()).then(() => value)
    117.         }, reason => {
    118.             return PromiseOfMine.reject(callback()).then(() => { throw reason })
    119.         })
    120.     }
    122.     catch = (failCallback) => {
    123.         return this.then(undefined, failCallback)
    124.     }
    126.     static all = (array) => {
    127.         let result = []
    128.         let process = 0
    130.         return new PromiseOfMine((resolve, reject) => {
    131.             function addData(index, value) {
    132.                 result[index] = value
    133.                 process++
    134.                 if (process === array.length) {
    135.                     resolve(result)
    136.                 }
    137.             }
    138.             for (let i = 0; i < array.length; i++) {
    139.                 if (array[i] instanceof PromiseOfMine) {
    140.                     array[i].then(value => { addData(i, value) }, reason => reject(reason))
    141.                 } else {
    142.                     addData(i, array[i])
    143.                 }
    144.             }
    145.         })
    146.     }
    148.     static race = (array) => {
    149.         return new PromiseOfMine((resolve, reject) => {
    150.             for (let i = 0; i < array.length; i++) {
    151.                 array[i].then(data => {
    152.                     resolve(data)
    153.                 }, err => {
    154.                     reject(err)
    155.                 })
    156.             }
    157.         })
    158.     }
    160.     static resolve = (value) => {
    161.         if (value instanceof PromiseOfMine) {
    162.             return value
    163.         } else {
    164.             return new PromiseOfMine(resolve => resolve(value))
    165.         }
    166.     }
    168.     static reject = (reason) => {
    169.         if (reason instanceof PromiseOfMine) {
    170.             return reason
    171.         } else {
    172.             return new PromiseOfMine((undefined, reject) => reject(reason))
    173.         }
    174.     }
    175. }
    177. function resolvePromise(newPromise, x, resolve, reject) {
    178.     // x就是newPromise
    179.     if (newPromise === x) {
    180.         return reject(new TypeError('error：promise循环调用'))
    181.     }
    183.     // x是一个函数或对象的情况,x就有可能是一个promise
    184.     let called// 保证只能调用成功或者失败，不能让用户两个都调用
    185.     if (x != null && (typeof x === 'function' || typeof x === 'object')) {
    186.         try {
    187.             let then = x.then;
    188.             if (typeof then === 'function') {
    189.                 then.call(x, (value) => {
    190.                     if (called) {
    191.                         return
    192.                     } else {
    193.                         called = true
    194.                     }
    195.                     // value可能还是一个promise，所以递归处理, 直到最终返回一个普通值为止
    196.                     resolvePromise(newPromise, value, resolve, reject)
    197.                 }, (reason) => {
    198.                     if (called) {
    199.                         return
    200.                     } else {
    201.                         called = true
    202.                     }
    203.                     reject(reason)
    204.                 })
    205.             } else {
    206.                 // x.then是普通值{then:123}
    207.                 resolve(x)
    208.             }
    209.         } catch (e) {
    210.             if (called) {
    211.                 return
    212.             } else {
    213.                 called = true
    214.             }
    215.             reject(e)
    216.         }
    217.     }
    218.     // x是一个普通值
    219.     else {
    220.         resolve(x)
    221.     }
    222. }
    224. PromiseOfMine.deferred = function () {
    225.     let dfd = {};
    226.     dfd.promise = new PromiseOfMine((resolve, reject) => {
    227.         dfd.resolve = resolve;
    228.         dfd.reject = reject;
    229.     });
    230.     return dfd;
    231. }
    233. module.exports = PromiseOfMine;