手写promise

1. 每个promise都有一个内部属性[[PromiseState]]被用来表示Promise的三种状态,初始化的状态都是pending。
2. 所有的promise都有then()方法：接受两个参数，一个是当promise的状态变为fulfilled时，要调用的函数，第二个是当Promise状态变为rejected时，需要调用的函数
3. 用Promise构造函数可以创建新的Promise，构造函数接受初始化Promise代码的executor，executor里面有两个参数，一个是`resolve，一个是reject```。

依据这些内容，我们可以搭建出promise的大概架构：

const PENDING = 'PENDING';
const FULLFILLED = 'FULLFILLED';
const REJECTED = 'REJECTED';

class NewPromise {
  
  constructor(executor) {
    // 每个promise 初始化状态是pending
    this._currentState = PENDING;
    let resolev = () => {};
    let reject = () => {};

    // 构造函数中立即执行构造器
    executor(resolev, reject);
    
  }
  then(onResolved, onRejected) {}
  catch (cb) {
      return this.then(null, cb)
  }
}

promise的状态变化

• executor函数报错 直接执行reject();
• 当执行期成功时，不可转为其他状态，且必须有一个不可改变的值（value）
• 当执行期失败时，不可转为其他状态，且必须有一个不可改变的原因（reason）

constructor(executor) {
    // 每个promise 初始化状态是pending
    this._currentState = PENDING;
    // 成功的值
    this.value = undefined;
    // 失败的原因
    this.reason = undefined;
    let resolve = (value) => {
      // 执行器调用resolve后,promise的状态变为成功
      this._currentState = FULLFILLED;
      // 储存成功的值
      this.value = value;
    };
    let reject = (reason) => {
      // 执行器调用reject后,promise的状态变为失败
      this._currentState = REJECTED;
      // 储存失败的原因
      this.reason = reason;
    };
    // 构造函数中立即执行构造器
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err)
    } 
  }

then方法的实现

• then方法的两个参数都是可选的
• 当状态state为fulfilled，则执行onFulfilled，传入this.value。当状态state为rejected，则执行onRejected，传入this.reason
• onFulfilled,onRejected如果他们是函数，则必须分别在fulfilled，rejected后被调用，value或reason依次作为他们的第一个参数

then(onResolved, onRejected) {
    // 状态为fulfilled，执行onFulfilled，传入成功的值
    if (this.state === FULLFILLED) {
      onResolved(this.value);
    };
    // 状态为rejected，执行onRejected，传入失败的原因
    if (this.state === REJECTED) {
      onRejected(this.reason);
    };
  }

• 由于一个promise可以有多个then，所以存在先将then里面的两个函数储存起来数组内。

Promise的链式调用

我门常常用到new Promise().then().then(),这就是链式调用,链式调用在then方法中返回了一个新的promise

1. 为了达成链式，我们默认在第一个then里返回一个promise。规定了一种方法，就是在then里面返回一个新的promise,称为promise2：promise2 = new Promise((resolve, reject)=>{})

• 将这个promise2返回的值传递到下一个then中
• 如果返回一个普通的值，则将普通的值传递给下一个then中

2、当我们在第一个then中return了一个参数（参数未知，需判断）。这个return出来的新的promise就是onFulfilled()或onRejected()的值。

then(onFulfilled,onRejected) {
    // 声明返回的promise2
    let promise2 = new Promise((resolve, reject)=>{
      if (this.state === 'fulfilled') {
        let x = onFulfilled(this.value);
        // resolvePromise函数，处理自己return的promise和默认的promise2的关系
        resolvePromise(promise2, x, resolve, reject);
      };
      if (this.state === 'rejected') {
        let x = onRejected(this.reason);
        resolvePromise(promise2, x, resolve, reject);
      };
      if (this.state === 'pending') {
        this.onResolvedCallbacks.push(()=>{
          let x = onFulfilled(this.value);
          resolvePromise(promise2, x, resolve, reject);
        })
        this.onRejectedCallbacks.push(()=>{
          let x = onRejected(this.reason);
          resolvePromise(promise2, x, resolve, reject);
        })
      }
    });
    // 返回promise，完成链式
    return promise2;
  }