存档.html

<script>
  Function.prototype.bind =  function (ctx,...rest){
    let self = this
    let newFn = function (...args){
      self.call(this instanceof newFn ? this : ctx, ...self, ... args)
    }
    if(self.prototype){
      newFn.prototype = Object.create(self.prototype)
    }
    return newFn
  }
  Function.prototype.call =  function (ctx,...rest){
    ctx = Object(ctx) || window
    let fn = Symbol('fn')
    ctx[fn] = this
    let res = ctx[fn](...rest)
    delete  ctx[fn]
    return res
  }
  function curry(fn){
    return function curried(...args){
        if(args.length >= fn.length){
            return fn(...args)
        }else {
           return function (...args2){
             return curried(...args,...args2)
           }
        }
    }
  }
  function _new(fn,...rest){
    let newObj = Object.create(fn.prototype)
    let result = fn.apply(newObj, rest)
    return typeof result === 'object' ? result || newObj : newObj
  }
</script>
<script>


  class Promise {
    constructor(fn) {
      this.status = 'p'
      this.value = undefined
      this.reason = undefined
      this.onResArr = []
      this.onRejArr = []
      let resolve =(val)=>{
        if(this.status === 'p'){
          this.status = 'f'
          this.value = val
          this.onResArr.forEach((fn)=>fn())
        }
      }
      let reject = (val)=>{
        if(this.status === 'p'){
          this.status = 'r'
          this.reason = val
          this.onRejArr.forEach((fn)=>fn())
        }
      }
      try{
        fn(resolve, reject)
      } catch(error){
        reject(error)
      }
    }

    then (onFulfilled, onRejected){
      onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : (v)=>v
      onRejected = typeof onRejected === 'function' ? onRejected : (err)=> { throw err}
      let nextPromise = new Promise((resolve, reject)=>{
        if(this.status === 'f'){
          setTimeout(()=>{
            try {
              let res = onFulfilled(this.value)
              resolve(res)
            }catch(err){
              reject(err)
            }
          })
        }

        if(this.status === 'r'){
          setTimeout(()=>{
            try{
              let res = onRejected(this.reason)
              this.resolvePromise(nextPromise, res, resolve, reject)
            }catch(e){
              reject(e)
            }
          })
        }

        if(this.status === 'p'){
          this.onResArr.push(()=>{
            setTimeout(()=>{
              try{
                let res = onFulfilled(this.value)
                this.resolvePromise(nextPromise,res,resolve,reject)
              }catch(e){
                reject(e)
              }
            })
          })
          this.onRejArr.push(()=>{
            setTimeout(()=>{
              try{
                let res = onRejected(this.value)
                this.resolvePromise(nextPromise,res,resolve,reject)
              }catch(e){
                reject(e)
              }
            })
          })
        }
      })
      return nextPromise
    }

    resolvePromise(nextPromise, res, resolve, reject){
        if(nextPromise === res) {return reject(new TypeError('xxxxxx'))}
        let called
      if(typeof res ==='object' && res!==null || typeof res === 'function'){
        try{
          let then = res.then
          if(typeof then === 'function'){
            then.call(res,val=>{
              if(called) return
              called = true
              this.resolvePromise(nextPromise, val, resolve, reject)
            },rej=>{
              if(called) return
              called = true
              reject(rej)
            })
          }else {
            resolve(res)
          }
        }catch (e){
          if (called) return;
          called = true;
          reject(e)
        }
      }else {
        resolve(res)
      }
    }
  }
</script>