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

Optimize ：
1、 Realization Promise.then You can chain call
2、Promise.then It's an asynchronous task

// 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
    onRejectedCallback = typeof onRejectedCallback === 'function' ? onRejectedCallback : reason => reason

    //  You can chain call , be then It must be a Promise
    return new Promise((resolve, reject) => {
    
    //  utilize setTimeout Solve the asynchronous problem 
      if(this.state === FULFILLED) {
    
        setTimeout(() => {
    
          let res = onFulfilledCallback(this.value)
          resolve(res)
        })
      }
      
      if(this.state === REJECTED) {
    
        setTimeout(() => {
    
          let err = onRejectedCallback(this.reason)
          reject(err)
        })
      }
      
      //  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(() => {
    
            let res = onFulfilledCallback(value)
            resolve(res)
          })
        }) 
        this.onRejectedCallbacks.push((reason) => {
    
          setTimeout(() => {
    
            let err = onRejectedCallback(reason)
            reject(err)
          })
        })   
      }
    })
  }
}

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

p.then(res => {
    
  console.log(res)
  return 2
}).then(res => {
    
  console.log(res)
  console.log(3)
})

console.log(5)

// 2, 5, 1, 2, 3