1. const PENDING = 'pending'
    2. const FULFILLED = 'fulfilled'
    3. const REJECTED = 'rejected'
    5. class Promise {
    6.   constructor(executor) {
    7.     this.state = PENDING
    8.     this.value = null
    9.     this.reason = null
    10.     this.onFulfilledCallbacks = []
    11.     this.onRejectedCallbacks = []
    12.     const resolve = value => {
    13.       setTimeout(() => {
    14.         if (this.state === PENDING) {
    15.           this.state = FULFILLED
    16.           this.value = value
    17.           this.onFulfilledCallbacks.forEach(cb => {
    18.             cb = cb(this.value)
    19.           })
    20.         }
    21.       });
    22.     }
    23.     const reject = reason => {
    24.       setTimeout(() => {
    25.         if (this.state === PENDING) {
    26.           this.state = REJECTED
    27.           this.reason = reason
    28.           this.onRejectedCallbacks.forEach(cb => {
    29.             cb = cb(this.reason)
    30.           })
    31.         }
    32.       });
    33.     }
    34.     try {
    35.       executor(resolve, reject)
    36.     } catch (e) {
    37.       reject(e)
    38.     }
    39.   }
    40.   then(onFulfilled, onRejected) {
    41.     onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value
    42.     onRejected = typeof onRejected === 'function' ? onRejected : reason => {
    43.       throw reason
    44.     }
    45.     let newPromise
    46.     if (this.state === FULFILLED) {
    47.       return (newPromise = new Promise((resolve, reject) => {
    48.         setTimeout(() => {
    49.           try {
    50.             let x = onFulfilled(this.value)
    51.             resolvePromise(newPromise, x, resolve, reject)
    52.           } catch (e) {
    53.             reject(e)
    54.           }
    55.         });
    56.       }))
    57.     }
    58.     if (this.state === REJECTED) {
    59.       return (newPromise = new Promise((resolve, reject) => {
    60.         setTimeout(() => {
    61.           try {
    62.             let x = onRejected(this.reason)
    63.             resolvePromise(newPromise, x, resolve, reject)
    64.           } catch (e) {
    65.             reject(e)
    66.           }
    67.         });
    68.       }))
    69.     }
    70.     if (this.state === PENDING) {
    71.       return (newPromise = new Promise((resolve, reject) => {
    72.         this.onFulfilledCallbacks.push(value => {
    73.           try {
    74.             let x = onFulfilled(value)
    75.             resolvePromise(newPromise, x, resolve, reject)
    76.           } catch (e) {
    77.             reject(e)
    78.           }
    79.         })
    80.         this.onRejectedCallbacks.push(reason => {
    81.           try {
    82.             let x = onRejected(reason)
    83.             resolvePromise(newPromise, x, resolve, reject)
    84.           } catch (e) {
    85.             reject(e)
    86.           }
    87.         })
    88.       }))
    89.     }
    90.   }
    91. }
    93. function resolvePromise(promise2, x, resolve, reject) {
    94.   if (x === promise2) {
    95.     reject(new TypeError())
    96.   }
    97.   if (x instanceof Promise) {
    98.     if (x.state === PENDING) {
    99.       x.then(y => {
    100.         resolvePromise(promise2, y, resolve, reject)
    101.       }, reason => {
    102.         reject(reason)
    103.       })
    104.     } else {
    105.       x.then(resolve, reject)
    106.     }
    107.   } else if (x && (typeof x === 'function' || typeof x === 'object')) {
    108.     let called = false
    109.     try {
    110.     let then = x.then
    111.       if (typeof then === 'function') {
    112.         then.call(x, y => {
    113.           if (called) return
    114.           called = true
    115.           resolvePromise(promise2, y, resolve, reject)
    116.         }, r => {
    117.           if (called) return
    118.           called = true
    119.           reject(r)
    120.         })
    121.       } else {
    122.         resolve(x)
    123.       }
    124.     } catch (e) {
    125.       if (called) return
    126.       called = true
    127.       reject(e)
    128.     }
    129.   } else {
    130.     resolve(x)
    131.   }
    132. }