promise的实现

没懂，先记下来，后面再理解

// 标准 promise A+ 



const isFunction = function (fun) {
  return typeof fun == 'function'

}
const isPromise = (result)=>{
  return result instanceof Promise1

}
const isObject = obj => !!(obj && typeof obj === 'object')
const isThenable = (result)=> {
  return (isFunction(result)||isObject(result))&&'then' in result

}
const resolvePromise = function (promise, result, resolve, reject) {
  if (result === promise) {
    let reason = new TypeError('Can not fufill promise with itself')
    return reject(reason)
  }

  if (isPromise(result)) {
    return result.then(resolve, reject)
  }
  // ???
  if (isThenable(result)) {
    try {
      let {then} = result;
      if (isFunction(then)) {
        return new Promise(then.bind(result)).then(resolve, reject)
      }
    } catch (error) {
      return reject(error)
    }
  }
  resolve(result)

}


const handleCallback = function (callback, state, result) {
  let {onFulfilled, onRejected, resolve, reject} = callback;
  try {
    if (state === 'fulfilled') {
      isFunction(onFulfilled) ? resolve(onFulfilled(result)) : resolve(result)
    } else if (state == 'rejected') {
      isFunction(onRejected) ? resolve(onRejected(result)) : resolve(result)
    }
  } catch (error) {
    reject(error)
  }
}
const handleCallbacks = (callbacks,state,result)=>{
  while(callbacks.length){
    handleCallback(callbacks.shift(),state,result)
  }
}

const transition = (promise, state, result)=> {
  if (promise.state !== 'pending') {
    return;
  }
  promise.state = state;
  promise.result = result;
  setTimeout(()=>handleCallbacks(promise.callbacks,state,result),0)
}
function Promise1(f) {
  this.state = 'pending';
  this.result = null;
  this.callbacks = [];

  let onFulfilled = (value)=> {
    return transition(this, 'fulfilled', value)
  }
  let onRejected = reason=> transition(this, 'rejected', reason)

  let ignore = false;
  let resolve = value=>{
    if(ignore) return;
    ignore = true;
    resolvePromise(this,value,onFulfilled,onRejected);
  }

  let reject = reason =>{
    if(ignore) return ;
    ignore = true;
    onRejected(reason)
  }
  try{
    f(resolve,reject)
  }catch (error){
    reject(error)
  }


}







Promise1.prototype.then = function (onFulfilled, onRejected) {
  return new Promise1((resolve, reject)=> {
    let callback = {onFulfilled, onRejected, resolve, reject};
    if (this.state === 'pending') {
      this.callbacks.push(callback);
    } else {
      setTimeout(()=> {
        handleCallback(callback, this.state, this.result)
      }, 4)
    }
  })

}

let promise = new Promise1((resolve, reject)=> {

  resolve(1);
})

promise.then((res)=> {
  console.log("res===========", res);
})

原文

https://mp.weixin.qq.com/s/qdJ0Xd8zTgtetFdlJL3P1g