Promise常见的几个关键问题

一.Promise 对象状态改变的方式

1.resolve 函数 pending => fulfilled (resolve)

2.reject 函数 pending => rejected

3.抛出错误

 let p = new Promise((resolve, reject) => {
        //1.resolve 函数   pending => fulfilled (resolve)
        resolve('ok')
        //2.reject 函数   pending => rejected
        reject("error")
        //3.抛出错误
        throw '出问题了'
    })
    console.log('状态', p)

二.一个promise指定多个成功/失败回调函数，都会调用吗？

答：当promise改变对应状态时都会调用

// promise指定多个回调，回调1和2都会打印
    let p = new Promise((resolve, reject) => {
        resolve('ok')
    })
    //指定回调 - 1
    p.then(value => console.log('第一次回调', value))
    //指定回调 - 2
    p.then(value => console.log('第二次回调', value))

三.改变promise状态和指定回调函数谁先谁后？

1.都有可能，正常情况下是先指定回调再改变状态，但也可以先改状态再指定回调

2.如何先改状态再指定回调？

（1）在执行器中直接调用resolve() / reject()
（2）延迟更长时间才调用then()

3.什么时候才能得到数据

（1）如果先指定的回调，那当状态发生改变时，回调函数就会调用，得到数据
（2）如果先改变的状态，那当指定回调时，回调函数就会调用，得到数据

//3.改变promise状态和指定回调函数谁先谁后
    let p = new Promise((resolve, reject) => {
        // resolve('ok') //改变状态先执行，then后执行
        //异步任务的时候,.then先执行，改变状态后执行
        setTimeout(() => {
            resolve('ok')
        }, 1000);
    })

    p.then(res => console.log('成功', res))
        .catch(err => console.log('失败', err))

四.promise.then(）返回的新promise的结果状态由什么决定？

1.简单表达：由then()指定的回调函数执行的结果决定

2.详细表达：

（1）如果抛出异常，新promise变为reject , reason为抛出的异常
（2）如果返回的是非promise的任意值，新promise变为resolved,value为返回的值
（3）如果返回的是另一个新promise,此promise的结果就会成为新promise的结果

//4.promise.then(）返回的新promise的结果状态由什么决定？
    let p = new Promise((resolve, reject) => {
        resolve('ok')
    })
    let resule = p.then(res => {
        // console.log('成功', res)
        /* 1.抛出异常
        [[PromiseState]]: "rejected"
        [[PromiseResult]]: "出了问题" */
        
        // throw '出了问题'
        
        /* 2.返回结果是一个非promise类型的对象
        [[PromiseState]]: "fulfilled"
        [[PromiseResult]]: 521 */
        
        // return 521;

        /* 3.如果返回的结果是promise对象  
         [[PromiseState]]: "fulfilled"
         [[PromiseResult]]: "success" */
        return new Promise((resolve,reject) => {
            resolve('success')
        })
    }, reason => console.log('失败', reason))
    console.log('result', resule)

五.promise如何串联多个操作任务

1.promise的then()返回一个新的promise，可以开成then()的链式调用

2.通过then的链式调用串连多个同步 / 异步任务

//5.promise如何串联多个操作任务
    let p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('ok')
        }, 1000);
    })

    p.then(res => { return new Promise((resolve, reject) => { resolve('success') }) })
        .then(res => console.log('res', res)) // 返回success
        .then(res => console.log('res', res)) //因为没有返回值，返回undefined

六.promise异常穿透？

当使用promise的then链式调用时，可以在最后指定失败的回调

前面任何操作出了异常，都会传到最后失败的回调中处理

 //6.promise异常穿透
    let p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('ok')
            // reject('Err')
        }, 1000);
    })

    p.then(res => {
        console.log('res',111)
        throw '失败了'
    })
        .then(res => console.log('res', 222)) // 返回success
        .then(res => console.log('res', 333)) //因为没有返回值，返回undefined
        .catch(reason => console.log('失败',reason)) // 失败了

七.中断promise链？

1.当使用promise的then链式调用时，在中间中断，不再调用后面的回调函数

2.办法：在回调函数中返回一个pending状态的promise对象

 //7.中断promise链
    let p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('ok')
            // reject('Err')
        }, 1000);
    })

    p.then(res => {
        console.log('res',111)
        //有且只有一种方式
        return new Promise(() => {})
    })
        .then(res => console.log('res', 222)) // 返回success
        .then(res => console.log('res', 333)) //因为没有返回值，返回undefined
        .catch(reason => console.log('失败',reason)) // 失败了