Promise笔记2

promise几个关键问题

1. 如何改变 promise 的状态?

(1) resolve(value): 如果当前是pending就会变为 resolved
(2) reject(reason): 如果当前是pending就会变为rejected
(3) 抛出异常: 如果当前是pending就会变为 rejected

2. 一个 promise 指定多个成功/失败回调函数, 都会调用吗?

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

const promise = new Promise((resolve, reject) => {
    //resolve(1) // pending变为resolved成功状态
    //reject(2)  // pending变为rejected失败状态
    //throw new Error('有错误') //抛出异常， promse变为rejected失败状态,reason为抛出的error
    throw 3 //抛出异常,promise变为 rejected失败状态， reason为3
})
promise.then(
    value => { },
    reason => {
        console.log('reason', reason)
    }
)
promise.then(
    value => { },
    reason => {
        console.log('reason2', reason)
    }
)

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

(1) 正常情况下是先指定回调再改变状态, 但也可以先改状态再指定回调
(2) 如何先改状态再指定回调?
* 在执行器中直接调用 resolve()/reject()
* 延迟更长时间才调用 then()
(3) 什么时候才能得到数据?
*如果先指定的回调, 那当状态发生改变时, 回调函数就会调用, 得到数据
*如果先改变的状态, 那当指定回调时, 回调函数就会调用, 得到数据

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

4. promise.then()返回的新 promise 的结果状态由什么决定?

(1) 简单表达: 由 then()指定的回调函数执行的结果决定
(2) 详细表达:

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

5. promise 如何串连多个操作任务?

(1) promise 的 then()返回一个新的 promise, 可以开成 then()的链式调用
(2) 通过 then 的链式调用串连多个同步/异步任务

//第一个promise（执行第一个异步任务）
new Promise((resolve, reject) => {
    setTimeout(() => {
        console.log('第一个异步任务');
        resolve('异步：1');
    },1000)
})
    //第二个promise（执行第二个同步任务）
    .then(
        value => {
            console.log('获取第一个promise异步任务传来的数据：' + value);
            console.log('第二个同步任务');
            return '2';
        }
    )
    //第三个promise（执行第三个异步任务）
    .then(
        value => {
            console.log('获取第二个promise同步任务传来的数据：' + value);
            //注意这里返回的是一个新的promise对象，里面的异步操作得到的数据可以被传递下去
            //如果没有封装在promise对象里面，setTimeout里面的操作并不会立马执行，没有实现真正的串联操作
            return new Promise((resolve, reject) => {
                //进行异步操作
                setTimeout(() => {
                    console.log('第三个异步任务');
                    resolve('3');
                }, 2000)
            })
        }
    )
    //第四个promise（执行同步任务）
    .then(
        value => {
            console.log('获取第三个promise异步任务传来的数据：' + value);
            console.log('第四个同步任务');
            return '4';
        }
    )

6. promise 异常传透?

(1) 当使用 promise 的 then 链式调用时, 可以在最后指定失败的回调,
(2) 前面任何操作出了异常, 都会传到最后失败的回调中处理

7. 中断 promise 链?

(1) 当使用 promise 的 then 链式调用时, 在中间中断, 不再调用后面的回调函数
(2) 办法: 在回调函数中返回一个 pending 状态的 promise 对象

   return new Promise(()=>{}); // 返回“pending”状态的Promise对象