class myPromise {

  constructor(fn) {

    this.status = 'pending';

    this.resolveCbs = [];

    this.rejectCbs = [];

    this.value = null;

    fn(this._resolve.bind(this), this._reject.bind(this));

    return this;

  }

  _resolve(val) {

    if (this.status === 'pending') {

      this.value = val;

      this.status = 'fulfilled';

      this.resolveCbs.forEach(cb => {

        cb(this.value);

      })

    }

  }

  _reject(err) {

    if (this.status === 'pending') {

      this.value = err;

      this.status = 'rejected';

      this.rejectCbs.forEach(cb => {

        cb(this.value);

      })

      // 如果没有处理函数，则直接抛错

      if (this.rejectCbs.length === 0) {

        throw err

      }

    }

  }

  then(resolveCb, rejectCb) {

    if (this.status !== 'pending') {

      const cb = this.status === 'fulfilled' ? resolveCb : rejectCb;

      const self = new myPromise((resolve, reject) => {

        this._handleCb(cb, this.value, resolve, reject, self);

      })

      return self;

    } else {

      const self = new myPromise((resolve, reject) => {

        if (typeof resolveCb === 'function') {

          this.resolveCbs.push(res => {

            this._handleCb(resolveCb, res, resolve, reject, self);

          })

        }

        if (typeof rejectCb === 'function') {

          this.rejectCbs.push(res => {

            this._handleCb(rejectCb, res, resolve, reject, self);

          })

        }

      })

      return self;

    }

  }

  catch(rejectCb) {

    return this.then(null, rejectCb)

  }

  _handleCb(cb, res, resolve, reject, self) {

    try {

      const ret = cb(res)

      if (ret instanceof Promise || ret instanceof myPromise) {

        if (ret === self) {

          throw new Error('检测到myPromise链式循环')

        }

        ret.then(res => resolve(res))

      } else {

        resolve(ret)

      }

    } catch (err) {

      reject(err)

    }

  }

}

new myPromise((resolve, reject) => {

  setTimeout(() => {

    resolve(456)

  }, 1000);

}).then(res => {

  console.log(res)

  throw 'hualala'

}).catch(err => {

  console.log('heng!!!')

  return new myPromise((resolve, reject) => {

    setTimeout(() => {

      reject(233)

    }, 1000);

  })

}).then(res => {

  console.log(res)

})