promise特点

promise 为什么会产生  解决异步问题

1.多个异步请求并发（希望同步最终的结果）promise.all

2.链式异步请求的问题 上一个人的输出是下一个人的输入 promise的链式调用可以解决这个问题

3.缺陷：还是基于回调

 

1. promis有三个状态：成功态resolve，失败态reject， 等待态pending

promise就是一个类 new Promise((resolve,  reject) => {

2. 用户自己决定成功的原因和失败的原因， 成功和失败也是用户定义的

3. 默认执行器立即执行

})

4. promise的实例都有一个then方法，一个参数是成功的回调，另一个参数是失败的回调

promise.then((data) => {

  console.log('success');

}, (err) => {

  console.log('fail');

})

多个then时，从其中一个中终断向下传递的方法，then(() => return new Promise((resolve, reject) => {}) ), 不成功也不失败

5. 如果执行函数时发生了异常也会执行失败逻辑

6. 如果promise一旦成功就不能失败，反过来也是

 

class Promise {
    constructor(executor) {
        this.status = PENDING;
        this.value = undefined;
        this.reason = undefined;
        this.onResolveCallBacks = [];
        this.onRejectCallBacks = [];
        let resolve = (value) => {
            if(this.status === PENDING) {
                this.value = value;
                this.status = RESOLVED;
                this.onResolveCallBacks.forEach(fn=>fn());
            }
        }
        let reject = (reason) => {
            if(this.status === PENDING) {
                this.reason = reason;
                this.status = REJECTED;
                this.onRejectCallBacks.forEach(fn=>fn());
            }
        }
        try{
            executor(resolve, reject); // 立即执行
        }catch(e){
            reject(e);
        }
       
        then(onFulfilled, onRejected) { //每次调then都new一个promise
          let promise2 = new Promise((resolve, reject) => { // 为了链式调用
            if(this.status === RESOLVE) { 
                let x = onFulfilled(this.value);
                resolve(x);
            }
            if(this.status === REJECTED) { 
                onRejected(this.reason);
            }
            if(this.status === PENDING){
             // 2. 发布订阅模式 如果当前状态时pending，我们需要将成功和失败的回调存放起来，稍后调用resole和reject的时候重新执行
                this.onResolvedCallbacks.push(() => {
                    // todo...
                    onFulfilled(this.value);
                })
                this.onRejectCallBacks.push(() => {
                    // todo...
                    onRejected(this.reason);
                })
            }
            

    
          })
          return promise2;
        }
    }
}
module.exports = Promise

// error first 错误第一 异步方法无法通过try catch捕获异常

1.promise成功和失败的回调的返回值 可以传到外层的下一个then

2.如果返回的是普通值的话（不是报错、不是promise）（传递到下一次的成功中），出错的情况（一定会走到下一次的失败），可能还有promise的情况（会采用promise的状态，决定下一次的成功还是失败）

3.错误处理 如果离自己最近的then 没有错误处理 会向下找

4.每次执行完promise.then方法后返回的都是一个“新的promise”(promise一旦成功或失败就不能修改状态)