Node.js 学习笔记01|同步、异步；Promise

qq_32765047

已于 2023-04-09 08:09:22 修改

阅读量206

点赞数

分类专栏： Node.js 文章标签：学习

于 2023-04-02 13:08:15 首次发布

本文链接：https://blog.csdn.net/qq_32765047/article/details/129893091

版权

Node.js 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

01.进程和线程

进程：程序运行的环境

线程：实际运行运算的东西

02. 同步

通常情况下代码都是自上向下一行一行执行的。前面的代码不执行后面的代码也不会执行。因此，同步的代码执行会出现阻塞的情况，一行代码执行慢会影响到整个程序的执行。如：setTimeout方法

setTimeout(()=>{
     return a + b
    },10000)

解决同步问题：

java python 使用多线程解决，在node.js中通过异步方式解决

03. 异步

异步代码的执行不会影响其他代码执行，但是无法通过return来设置返回值

异步的特点：

1.不会阻塞其他代码的执行

2.需要通过回调函数来返回结果

异步的两种实现方式：

（1）回调函数

function sum(a,b,cb){
    const begin = Date.now()

    setTimeout(()=>{
        cb(a + b)
    },10000)

}

但是该方法代码可读性差，可调试性差也容易出现回调地狱

（2）Promise

Promise是一个可以用来存储数据的对象，存储数据的方式比较特殊，这种特殊方式使得Promise可以用来存储异步调用的数据。Promise可以解决异步中回调函数的问题。它可以存储异步调用的结果

从Promise中读取数据（实例方法 then）

then需要两个回调函数作为参数，回调函数用来获取Promise中的数据

resolve：通过resolve存储的数据，会调用第一个函数返回，可以在第一个函数中编写处理数据的代码

reject：通过reject存储的数据或者出现异常时，会调用第二个函数返回，可以在第二个函数中编写处理异常的代码
//创建Promise
//构造函数中需要一个函数作为参数
//Promise 构造函数的回调函数，它会在创建Promise时调用，调用时会有两个参数传递进去
const promise = new Promise((resolve,reject)=>{
    //resolve 和 reject是两个函数，通过这两个函数可以向Promise中存储数据
    //resolve 在执行正常时存储数据，reject 在执行错误时存储数据
    resolve("hhh")
    // setTimeout(()=>{
    //     resolve("hhh")
    // },2000)
    throw new Error("出错了")
}) 

promise.then((result) => {
     console.log("1",result);
 },(reason) => {
     console.log("2",reason);
 })

const promise2 = new Promise((resolve,reject) => {
    resolve("hhh")  //等于 Pormise.resolve("hhh")
})

Promise中维护了两个隐藏属性：

PromiseResult：用来存储数据

PromiseState：记录Promise状态

fulfilled（完成）通过resolve存储数据时

rejected（拒绝，出错了）出错了或者通过reject存储数据

pending（正在存储中，进行中）

NOTE：state只能修改一次，修改以后永远不会再变

流程：

当promise创建时，PromiseState初始值为pending

当通过resolve存储数据时 PromiseState变成fulfilled

PromiseResult变为存储的数据

当通过reject存储数据时 PromiseState变成rejected

PromiseResult变为存储的数据或异常对象

当通过then读取数据时，相当于为Promise设置了回调函数

如果PromiseState变为fulfilled时，则调用then的第一个回调函数来返回

如果PromiseState变为rejected时，则调用then的第二个回调函数来返回

其他方法：

catch()用法和then类似，但只需一个回调函数作为参数

catch()中的回调函数只会在Promise被拒绝时才调用

catch()相当于then(null,reason =>{})\

catch()是一个专门处理Promise异常的方法

finally()

无论是正常存储数据还是异常，finally总会执行

但是finally的回调函数中不会接收到数据

finally()通常用来编写一些无论成功与否都要执行的代码

04.Promise的链式调用

Promise就是一个用来存储数据的对象，但是由于Promise存储的方式的特殊，所以可以直接将异步调用的结果存储到Promise中。

对Promise进行链式调用时：后面的方法（then和catch）读取的是上一步的执行结果，如果上一步的执行结果不是当前想要的结果，则跳过当前的方法

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

sum(123,456).then(result =>{
    console.log(result);
    return result
}).then(result =>{
    console.log(result+7);
    return result + 7
}).then(result =>{
    console.log(result+8);
})

//简略写法

sum(123,456)
    .then(result => result + 7)
    .then(result => result + 8)
    .then(result => console.log(result))

Promise中的

then （return new Promise（））

catch

finally

这三个方法都会返回一个新的Promise，Promise中会存储回调函数的返回值。但是finally没有返回值

//当Promise出现异常时，而整个调用链中没有出现catch，则异常会向外抛出

const promise = new Promise((resolve,reject) => {
    resolve("1-5")
    reject("false")
 })
promise
     .then(r => "hhh")
     .catch(r => {
        throw new Error("报错")
         console.log("出错了");
         return "hhh"
    }) 
    .then(r => console.log("第二个then",r))
    .catch(r => {
        console.log("又出错了")
     })//将错误写到最后可以获取所有错误

05.Promise的静态方法

静态方法

Promise.resolve() 创建一个立即完成的Promise
Promise.resolve(10).then(r => console.log(r))
Promise.reject() 创建一个立即拒绝的Promise
Promise.reject("false").catch(r => console.log(r))
Promise.all([...]) 同时返回多个Promise的执行结果

其中有一个报错就会返回错误
Promise.all([
    sum(123,455),
    sum(3,5),
    Promise.reject("hhhh"),
    sum(1,4)
]).then(r => console.log(r))
Promise.allSettled([...]) 同时返回多个Promise的执行结果无论成功或失败
Promise.allSettled([
    sum(123,455),
    sum(3,5),
    Promise.reject("hhhh"),
    sum(1,4)
]).then(r => console.log(r))
Promise.race([...]) 返回执行最快的Promise （不考虑对错）
Promise.race([ //谁最快执行谁
    Promise.resolve(1111),
    sum(123,455),
    sum(3,5),
    sum(1,4)
]).then(r => console.log(r))
Promise.any([...]) 考虑对错