Application of higher-order functions: handwritten promise source code (4)

1、 Optimize then Throw exception problem of method
2、 according to then The return value types of the two function parameters received by the method are processed differently

// promise/A+ The specification States promise There are three states , And once the state is changed, it cannot change again 
const PENDING = 'Pending'
const FULFILLED = 'Fulfilled'
const REJECTED = 'Rejected'
class Promise {
    
  //  Higher order function , The argument to a function is a function , Higher order functions can realize the preset of parameters 
  //  The function in the parameter of the function is the declaration of the function 
  // executor Is a function that executes immediately , Parameters are preset in constructor in 
  constructor(executor) {
    
    this.state = PENDING
    this.value = undefined         //  Successful results 
    this.reason = undefined        //  The reason for failure 
    
    //  solve then Problems that can be called multiple times 
    this.onResolvedCallbacks = []   
    this.onRejectedCallbacks = []

    const resolve = (value) => {
    
      if(this.state === PENDING) {
    
        this.state = FULFILLED
        this.value = value
        //  When the state changes, execute the callback function 
        this.onResolvedCallbacks.forEach(cb => cb(value))
      }
    }

    const reject = (reason) => {
    
      if(this.state === PENDING) {
    
        this.state = REJECTED
        this.reason = reason
        //  When the state changes, execute the callback function 
        this.onRejectedCallbacks.forEach(cb => cb(reason))
      }
    }
   
    //  Here is executor Function call . Parameters of the incoming resolve and reject Two functions 
    try {
    
      executor(resolve, reject)
    } catch(err) {
    
      reject(err)
    }
  }
  then(onFulfilledCallback, onRejectedCallback) {
    
    onFulfilledCallback = typeof onFulfilledCallback === 'function' ? onFulfilledCallback : value => value
    //  Optimization throwing exception 
    onRejectedCallback = typeof onRejectedCallback === 'function' ? onRejectedCallback : reason => {
     throw reason } 

    //  You can chain call , be then It must be a Promise
    let promise = new Promise((resolve, reject) => {
    
      if(this.state === FULFILLED) {
    
        //  Optimize to catch exceptions 
        setTimeout(() => {
    
          try {
    
            let res = onFulfilledCallback(this.value)
            //  according to res Different types of 
            resolvePromise(promise, res, resolve, reject)
          } catch(e) {
    
            reject(e)
          }
        })
      }
      
      if(this.state === REJECTED) {
    
        setTimeout(() => {
    
          try {
    
            let res = onRejectedCallback(this.reason)
            resolvePromise(promise, res, resolve, reject)
          } catch(e) {
    
            reject(e)
          }
        })
      }
      
      //  When executor When an asynchronous task occurs ,then When it comes to execution , The state has not changed , You can put the callback into the callback function array 
      if(this.state === PENDING) {
    
        this.onResolvedCallbacks.push((value) => {
    
          setTimeout(() => {
    
            try {
    
              let res = onFulfilledCallback(value)
              resolvePromise(promise, res, resolve, reject)
            } catch(e) {
    
              reject(e)
            }
          })
        }) 
        this.onRejectedCallbacks.push((reason) => {
    
          setTimeout(() => {
    
            try {
    
              let res = onRejectedCallback(reason)
              resolvePromise(promise, res, resolve, reject)
            } catch(e) {
    
              reject(e)
            }
          })
        })   
      }
    })
    return promise
  }
}

//  According to res The types are treated differently 
function resolvePromise(promise, res, resolve, reject) {
    
  if(res === promise) {
    
    return reject(new TypeError(' Dead cycle '))
  }

  if(res instanceof Promise) {
    
      try {
    
        res.then(x => {
    
          resolvePromise(promise, x, resolve, reject)
          // resolve(x)
        })
      } catch(e) {
    
        reject(e)
      }
  } else {
    
    resolve(res)
  }
}

let p = new Promise((resolve, reject) => {
    
	console.log(2)
	setTimeout(() => {
    
		resolve(1)
	}, 0)
})

let p2 = new Promise((resolve, reject) => {
    
  resolve(3)
})

let then = p.then(res => {
    
	console.log(res)
  return p2
}).then(res => {
    
  console.log(res)
})

console.log(5)

// 2, 5, 1, 3