2025-05-26 日报 Day198

今日的鸡汤

即便不与人为善，也别作恶，因为你的无礼拉低你的人品。

今日学习内容

1、https://medium.com/@happymishra66/prototypes-in-javascript-5bba2990e04b
2、https://mp.weixin.qq.com/s/qdJ0Xd8zTgtetFdlJL3P1g

const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';

function Promise(){
    this.state = PENDING;
    this.result = null;
    this.callbacks = [];

    let onFulfilled = value => transition(this, Fulfilled, value);
    let onRejected = error => transition(this, Rejected, error);

    let ignore = false;

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

    try { 
        f(resolve, reject);
    }catch (error) {
        onRejected(error);
    }

}

const transition = (promise, state, result) => {
    if (promise.state !== PENDING) return;
    promise.state = state;
    promise.result = result;
    setTimeout(()=>handleCallbacks(promise.callbacks, state, result), 0);
};
const handleCallbacks = (callbacks, state, result) => {
    while(callbacks.length) handleCallback(callbacks.shift(), state, result);
};

Promise.prototype.then = function(onFulfilled, onRejected){
    return new Promise((resolve, reject)=>{
        let callback = {
            onFulfilled: typeof onFulfilled === 'function' ? onFulfilled : (value) => value,
            onRejected: typeof onRejected === 'function' ? onRejected : (error) => { throw error; }
            resolve,
            reject
        };

        if(this.state === PENDING){
            this.callbacks.push(callback);
        }else{
            setTimeout(()=> handleCallback(callback, this.state, this.result), 0);
        }
    })
}

const handleCallback = (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)) : reject(result);
        }
    }catch(error){
        reject(error);
    }
}

const resolvePromise = (promise, result, resolve, reject) => {
    if(result === promise) {
        return reject(new TypeError('Chaining cycle detected for promise'));
    }

    if(isPromise(result)){
        return result.then(resolve, reject);
    }

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

    resolve(result);
}

const isFunction = obj => typeof obj === 'function'
const isObject = obj => !!(obj && typeof obj === 'object')
const isThenable = obj => (isFunction(obj) || isObject(obj)) && 'then' in obj
const isPromise = promise => promise instanceof Promise

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

function Promise(f) {
  this.result = null
  this.state = PENDING
  this.callbacks = []

  let onFulfilled = value => 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)
  }
}

Promise.prototype.then = function(onFulfilled, onRejected) {
  return new Promise((resolve, reject) => {
    let callback = { onFulfilled, onRejected, resolve, reject }

    if (this.state === PENDING) {
      this.callbacks.push(callback)
    } else {
      setTimeout(() => handleCallback(callback, this.state, this.result), 0)
    }
  })
}

const handleCallback = (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)) : reject(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)
}

const resolvePromise = (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.then
      if (isFunction(then)) {
        return new Promise(then.bind(result)).then(resolve, reject)
      }
    } catch (error) {
      return reject(error)
    }
  }

  resolve(result)
}

module.exports = Promise