Node.js异步编程

怼烎@ 2023-07-25 14:29 20阅读 0赞

## 连对象都会的（Node.js异步编程） ##

*  同步API,异步API  
    1.同步API 只有当前API执行完成，才能继续下个API  
    代码块

console.log('我是同步API');
    console.log('我也是同步API');

结果  
![在这里插入图片描述][20200415183027382.PNG_pic_center]  
2.异步API 当前API的执行不会阻塞后续代码的执行  
代码块

console.log('我是同步API');
    setTimeout(function() { 
        console.log('我是异步API');
    }, 2000);
    console.log('我也是同步API');

结果  
![在这里插入图片描述][20200415183107714.PNG_pic_center]

*  同步API,异步API的区别  
    1.获取返回值方式  
    同步API可以从返回值中拿到API的执行结果，但是异步API是不可以的；异步API的返回值通过回调函数拿到。  
    （1）同步函数获取返回值（略（哈哈哈，偷个懒））  
    （2）异步函数获取返回值  
    代码块

function getMsg(callback) { 
        setTimeout(function() { 
            callback({ 
                msg: '返回值获取成功'
            })
        }, 3000);
    }
    
    getMsg(function(data) { 
        console.log(data);
    })

2.代码执行顺序  
（1）同步API从上到下依次执行，前面代码会阻塞后面代码执行  
（2）异步API不会等待API执行完成后再执行代码  
（3）node.js 在从上到下执行代码时并不是遇到什么执行什么，而是先将所有的同步API执行完再去执行异步API

\*\*

## so同步咱都会，重点来了，异步怎么搞 ##

\*\*

*  node.js 中的异步API（异步API有很多，此处举两个例子：读取文件的API，事件监听的API（都有回调函数））
 *  那么上问题  
    1.eg:依据node.js代码执行顺序，如果异步API后面代码的执行依赖于异步API的执行结果，但实际上后续代码在执行的时候异步API还没有返回结果，这个问题怎么说。  
    fs.readFile(’’,(err,doc)=>\{\});  
    console.log(doc);  
    2.我们可以将返回结果写在回调函数内部（但如果需求为依次读取a,b,c文件，调用回调函数就会导致回调函数层次过多，导致代码难以维护）我们想三五个回调嵌套还好，大量的回调代码使项目难以维护，陷入回调地狱。  
    代码块（事先准备好txt文件，内容分别为1，2,3）

// !回调地狱
    const fs = require('fs')
    fs.readFile('./1.txt', 'utf8', (error, result1) => { 
        console.log(result1);
        fs.readFile('./2.txt', 'utf8', (error, result2) => { 
            console.log(result2);
            fs.readFile('./3.txt', 'utf8', (error, result3) => { 
                console.log(result3);
    
            })
        })
    
    })

结果  
![在这里插入图片描述][20200415184701385.PNG_pic_center]

*  Promise(es6)  
    1.Promise出现的目的是解决Node.js异步编程中回调地狱的问题（它可以让异步API的执行和结果的处理进行分离）  
    2.写法：let promise = new Promise(( resolve, reject)=>\{\})  
    3.第一个参数实际上是一个函数，当异步API有返回结果时调用，并且把异步API的返回结果通过参数的形式传出去.then()  
    4.第二个参数也是一个函数，当异步API执行失败时调用，把失败对象传递到promise以外去。在外边拿到promise返回的信息为promise下的.catch();  
    代码块

结果脑补下吧兄dei(hahaha)  
5.用promise解决回调地狱问题

//!用promise解决回调地狱问题
    const fs = require('fs');
    
    function p1() { 
        return new Promise((reslove, reject) => { 
            fs.readFile('./1.txt', 'utf8', (error, result) => { 
                reslove(result);
            })
        });
    }
    
    function p2() { 
        return new Promise((reslove, reject) => { 
            fs.readFile('./2.txt', 'utf8', (error, result) => { 
                reslove(result);
            })
        });
    }
    
    function p3() { 
        return new Promise((reslove, reject) => { 
            fs.readFile('./3.txt', 'utf8', (error, result) => { 
                reslove(result);
            })
        });
    }
    
    p1().then((r1) => { 
            console.log(r1);
            return p2();
        })
        .then((r2) => { 
            console.log(r2);
            return p3();
        })
        .then((r3) => { 
            console.log(r3);
    
        })

结果（当然还是1，2，3啦）

*  异步函数(es7)  
    1.异步函数的方法在Promise的基础上进行了封装  
    2.异步函数是异步编程语法的终极解决方案，它可以让我们将异步代码写成同步的形式，让代码不再有回调函数的嵌套，使代码变得清晰明了  
    3.定义语法（const fn = async() = >\{\} ，async function fn() \{\}）  
    4.含async和await关键字（细节在末尾（关键字总结））  
    代码块

async function fn() { 
        //throw '发生错误要抛出'
        return 123;
    }
    fn().then(function(data) { 
        console.log(data);
    }).catch(function(err) { 
        console.log(err);
    
    })

结果(当取消注释为第二个输出)  
![在这里插入图片描述][20200415185413274.PNG_pic_center]  
4.异步函数使用  
代码块

//!用异步函数解决回调地狱
    async function p1() { 
        return 'p1';
    }
    async function p2() { 
        return 'p2';
    }
    async function p3() { 
        return 'p3';
    }
    
    async function run() { 
        let r1 = await p1()
        let r2 = await p2()
        let r3 = await p3()
        console.log(r1);
        console.log(r2);
        console.log(r3);
    }
    run();

结果  
![在这里插入图片描述][20200415185646382.PNG_pic_center]  
5.异步函数解决回调地狱  
代码块（细节含注释）

//异步promise执行异步任务
    
    const fs = require('fs');
    //unil模块，下面有个方法promisify, 方法不调用 存入promisify中， 然后用这个方法对现有异步api进行包装，让它返回promise对象
    //改造现有API让其返回promise对象，从而支持异步算法
    const promisify = require('util').promisify;
    //调用promiseify方法改造现有异步API，让其返回promise对象
    const readFile = promisify(fs.readFile);
    
    async function run() { 
        let r1 = await readFile('./1.txt', 'utf8');
        let r2 = await readFile('./2.txt', 'utf8');
        let r3 = await readFile('./3.txt', 'utf8');
    
        console.log(r1);
        console.log(r2);
        console.log(r3);
    
    }
    run();

结果（当然是1，2，3啦）  
6.关键字的总结  
（1）async关键字  
1.普通函数加async关键字，普通函数就变成异步函数  
2.异步函数默认返回值是promise对象  
3.异步函数return关键字进行返回值，结果会包裹在promise对象中，return关键字代替了resolve方法  
4.如果异步函数执行出错（用throw关键字抛出错误（一旦执行后面代码不能执行））  
5.调用异步函数再链式调用then方法获取异步函数执行结果  
6.调用异步函数再链式调用catch方法获取异步函数执行的错误信息  
（2）await关键字  
1.await关键字只能出现在异步函数中  
2.await promise await后面只能写promise对象，写其他类型的API是不可以的  
3.await关键字可暂停异步函数向下执行，直到promise返回结果

**写在最后**  
搞了这么多，异步函数才是BOSS好嘛（偷偷告诉你：回过头看看年轻时的代码原来真的可以融会贯通）  
OVER

[20200415183027382.PNG_pic_center]: /images/20230528/e3a79eaa7f134e9896b97c61793c9c82.png
[20200415183107714.PNG_pic_center]: /images/20230528/8210a6909a9c41c3b5d6d3dd86b70ee6.png
[20200415184701385.PNG_pic_center]: /images/20230528/eefb997a7e6d4e20aea5c420a6a2c5dc.png
[20200415185413274.PNG_pic_center]: /images/20230528/29d585081b4c41668252092c86acbfea.png
[20200415185646382.PNG_pic_center]: /images/20230528/d239f8a2799144c8b490512efc9d6234.png