node.js 学习第二天 Promise 异步

promist

promise

promise就相当于是一个容器，可以直接把异步调用的结果存储到promise中，resolve是成功的内容，reject存储失败的内容

then

const promist = new Promise((resolve,reject) =>
    resolve(1)
}).then((data) =>{
    console.log(data)     //1
})

const promist = new Promise((resolve,reject) =>{

    reject(1)
}).then((data) =>{
    console.log(data)      //报错
})

这是因为then的第一个参数是获取resolve的数据，第二个参数是获取reject时调用

const promist = new Promise((resolve,reject) =>{
    //resolve(1)
    reject('err')
}).then((data) =>{
    console.log(data)
},(err) =>{
    console.log(err)     //err   
})

then的第二个回调函数会执行在执行时异常信息或时reject中返回的数据会作为参数传递

const promist = new Promise((resolve,reject) =>{
    //resolve(1)
    throw new Error("sdfwef");
  //  reject('err')
}).then((data) =>{
    console.log(data)
},(err) =>{
    console.log(err)     //sdfwef
})

catch

catch中只需要一个回调函数作为参数
catch中回调函数的作用等同于then中的第二个回调函数，会在执行出错时被调用。
开发时通常会在then中编写正常运行时的代码，catch中编写出现异常后要执行的代码

const promist = new Promise((resolve,reject) =>{
   reject('err')
}).catch((data) =>{
    console.log(data)    //err  catch 第一个参数就接受reject的值，then，要第二个参数才接收
})  

Finally

和then、catch不同，无论何种情况finally中的回调函数总会执行，
通常我们在finally中定义一些无论Promise正确执行与否都需要处理的工作。注意，finally的回调函数不会接收任何参数，同时finally的返回值也不会成为下一步的Promise中的结果。简单说，finally只是编写一些必须要执行的代码，不会对Promise产生任何实质的影响。

链式调用

then执行后每次总会返回一个新的Promise，并将then中回调函数的返回值存储到这个Promise中，如果没有指定返回值则新Promise中不会存储任何值。

const promise = new Promise((resolve, reject)=>{
    resolve("第一步执行结果")
})

promise.then(result => {
    console.log("收到结果：", result)
    return "第二步执行结果" // 会作为新的结果存储到新Promise中
}).then(result => {
    console.log("收到结果：", result)
    return "第三步执行结果" // 会作为新的结果存储到新Promise中
})

穿透

const promise = new Promise((resolve, reject)=>{
    resolve("第一步执行结果")
}).then(r => console.log("第一个then",r))
.catch(r => console.log("异常处理",r))   跳过catch
.then(r => console.log("第2个then",r))
//第一个then 第一步执行结果  
//第2个then undefined

const promise = new Promise((resolve, reject)=>{
    reject("第一步执行结果")
}).then(r => console.log("第一个then",r))
.catch(r => console.log("异常处理",r))
.then(r => console.log("第2个then",r))
//异常处理 第一步执行结果
//第2个then undefined

const promise = new Promise((resolve, reject)=>{
    reject("第一步执行结果")
}).then(r => console.log("第一个then",r))
.catch(r =>{ console.log("异常处理",r)
              return 'catch返回值'
           })
.then(r => console.log("第2个then",r))
//异常处理 第一步执行结果
//第2个then catch返回值

then和catch都可以返回值
then和catch 执行的是上一步的执行结果，如果上一步执行不是想要的结果，则跳过当前方法

静态方法

Promise.resolve()创建一个立即完成的promise

Promise.resolve(10)

等价于

new Promise ((resolve,reject) => {
    resolve(10)
})
同理  Promise.reject(10)   创建一个立即拒绝的

Promise.all

Promise.all 需要一个数组（可迭代对象）作为参数，数组中可以存放多个Promise。调用后，all方法会返回一个新Promise，这个Promise会在数组中所有的Promise都执行后完成，并返回所有Promise的结果
其中有一个报错，就返回错误结果

function sum(a, b) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(a + b)
        }, 5000);
    })
}

Promise.all([sum(1, 1), sum(2, 2), sum(3, 3)])
    .then((result) => {
        console.log(result)
    })

Promise.AllSettled

与all一致，返回多个promise的执行结果，无论成功与否都返回数据

Promise.race

谁执行快，拿谁的结果、忽略其它的执行，不考虑快的是否是错误结果

Promise.any

返回执行最快并且成功的 ，就是说只会返回第一个成功的Promise，忽略其它的，如果全部都报错，才会执行错误

时间轮询

栈：
队列：微任务队列、宏任务队列

• 先执行调用栈中的代码
• 执行微任务队列中的代码 .then() 、.catch() 、 .finally() 、queueMicrotask()
• 执行宏任务队列中的代码 setTimeout
  

Promise.resolve().then(()=>{
    Promise.resolve().then(()=>{
        console.log(1)
    })
})
queueMicrotask(()=>{
    console.log(2)
})

1.把第一个Promise.resolve().then(）放入微任务队列中
2.把queueMicrotask(）放入队列
3. 第一个Promise.resolve().then(）执行完，把第二个Promise.resolve().then(）放入微队列

console.log(1);

setTimeout(() => console.log(2));

Promise.resolve().then(() => console.log(3));

Promise.resolve().then(() => setTimeout(() => console.log(4)));

Promise.resolve().then(() => console.log(5));

setTimeout(() => console.log(6));

console.log(7);