javaScript中关于promise的关键问题，如何熟悉使用

1. promise有三种状态，pending 、fulfilled、rejected ，如何改变promise的状态

  let p1 = new Promise((resolve,reject) => {
    resolve('ok' )
  })
  let p2 = new Promise((resolve,reject) => {
    reject('error' )
  })
  let p3 = new Promise((resolve,reject) => {
     throw "error"
  })
   
  console.log("p1",p1)
  console.log("p2",p2)
  console.log("p3",p3)

 

•  throw、resolve(), reject 方法可以改变promise的状态

2. 一个 promise 指定多个成功/失败回调函数, 都会调用吗，如下所示：（注意 多个p.then()不会覆盖）

let p = new Promise((resolve, reject) => {
   resolve('OK');
})

p.then(res => {
   console.log('res1', res )
   throw 2
})
p.then(res => {
   console.log('res2', res + '+ok2')
})

 

•  由此可见 只要改变状态都会执行。

3.改变 promise 状态和指定回调函数谁先谁后，如下所示

//常规：先指定回调函数，后改变的状态
    new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('成功1') //后改变的状态（同时指定数据），异步执行回调函数
        }, 1000)
    }).then(//先指定回调函数，保存当前指定的回调函数
        value => {
            console.log('value1', value)
        },
        reason => {
            console.log('reason1', reason)
        }
    )

//如何向改变状态，再指定回调函数
    new Promise((resolve, reject) => {
        resolve('成功2') //先改变的状态（同时指定数据）
    }).then(//后指定回调函数，异步执行回调函数
        value => {
            console.log('value2', value)
        },
        reason => {
            console.log('reason2', reason)
        }
    )

• 都有可能, 正常情况下是先指定回调再改变状态, 但也可以先改状态再指定回调
• 如何先改状态再指定回调，在执行器中直接调用 resolve()/reject()，才调用 then()
• 如果先指定的回调, 那当状态发生改变时, 回调函数就会调用, 得到数据
• 如果先改变的状态, 那当指定回调时, 回调函数就会调用, 得到数据

4.Promise then方法的返回结果特点

let p = new Promise((resolve, reject) => {
     resolve('ok');
 })
let result = p.then(value => {
            //1 抛出错误
            //throw '出了问题'
            //2.返回结果不是Promise 对象 
            // return value
            //3 放回的结果是一个Promise对象
            return new Promise((reslove, reject) => {
                reslove(value)
            })
        }, reason => {
  console.log('reason', reason)
})

5. promise.then()的链式调用，会怎么执行

 new Promise((resolve, reject) => {
            resolve(1)
            //reject(1)
        }).then(
            value => {
               // 如果返回的是非promise的任意值，新的promise 变为resolved, value会反回值
                //return 2
                 //如果返回的是另一个新的promise, 此promise的结果就会成为新的promise的结果；
                // return Promise.resolve(3)
                //如果抛出异常：新的promise变为rejected,reason 为抛出异常
                 return Promise.reject(4)
                //throw 5 //抛异常
            },
            reason => {
                return '出错误1'
                console.log('onRejected1()', reason)

            }
        ).then(
            value => {
                console.log('onResolved2()', value)
            },
            reason => {
                console.log('onRejected2()', reason)
                return 21212
            }
        ).then(
            value => {
                console.log('onResolved3()', value)
            },
            reason => {
                console.log('onRejected3()', reason)
            }
        )

•  1. 如果抛出异常：新的promise变为rejected,reason 为抛出异常
•  2. 如果返回的是非promise的任意值，新的promise 变为resolved, value为放回值
•  3. 如果返回的是另一个新的promise, 此promise的结果就会成为新的promise的结果；

6.promise 的异常穿透

 let p = new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve('ok');
                // reject('err');
            }, 1000);
        });

        p.then(value => {
            console.log('111');
            throw '失败！';
        }).then(value => {
            console.log('222');
        }).then(value => {
            console.log('333');
        }).catch(reason => {
            console.warn(reason);
        });

•  不管哪一步报错，有报错就会走.catch()

7.promise链式调用如何中断

   let p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve('ok');
      }, 1000);
    });

    p.then(value => {
      console.log('111');
      return new Promise(() => {});
    }).then(value => {
      console.log('222');
    }).then(value => {
      console.log('333');
    }).catch(reason => {
      console.warn(reason);
    });

• 在回调函数中返回一个 pendding 状态的 promise 对象