Promise异步函数解决回调地狱

在根目录下创建1.txt、2.txt、3.txt

现在想要依次读取1.txt、2.txt、3.txt文件
要保证是依次读取，所以我们需要回调函数嵌套来保证是依次读取1.txt、2.txt、3.txt文件

const fs = require('fs');
fs.readFile('./1.txt', 'utf8', (err, result1) => {
    console.log(result1);

    fs.readFile('./2.txt', 'utf8', (err, result2) => {
        console.log(result2);

        fs.readFile('./3.txt', 'utf8', (err, result3) => {
            console.log(result3);
        })
    })
})

但是这就无可避免的造成了回调地狱现象，代码的可维护性也差，那么如何解决呢？
接下来我们使用到Promise，Promise的出现就是为了解决Node.js异步编程中回调地狱的问题

const fs = require('fs');
let promise = new Promise((resolve, reject) => {
    fs.readFile('./1.txt', 'utf8', (err, result) => {
        if (err != null) {
            reject(err);
        }else {
            resolve(result);
        }
    });
});
promise.then((result) => {
    console.log(result);
}).catch((err) => {
    console.log(err);
});

const fs = require('fs');
function p1() {
    return new Promise((resolve, reject) => {
        fs.readFile('./1.txt', 'utf8', (err, result) => {
            resolve(result);
        })
    })
}
function p2() {
    return new Promise((resolve, reject) => {
        fs.readFile('./2.txt', 'utf8', (err, result) => {
            resolve(result);
        })
    })
}
function p3() {
    return new Promise((resolve, reject) => {
        fs.readFile('./3.txt', 'utf8', (err, result) => {
            resolve(result);
        })
    })
}
p1().then((r1) => {
    console.log(r1);
    return p2();
}).then((r2) => {
    console.log(r2);
    return p3();
}).then((r3) => {
    console.log(r3);
})

使用Promise解决回调地狱的问题，虽然解决了回调地狱的问题，但是代码变得更多了有木有，这根本不是我们想要的结局啊啊啊
接下来我们了解一下异步函数

// async 关键字
// 1. 在普通函数定义的前面加上async关键字，普通函数就变成了异步函数
// 2. 异步函数默认的返回值是promise对象
// 3. 在异步函数内部使用throw关键字进行错误的抛出

// await关键字
// 1. 它只能出现在异步函数中
// 2. await promise 它可以暂停异步函数的执行，等待promise对象的返回结果在向下执行代码
// async function fn () {
//     throw '发生了一些异常';
//     return 123;
// };
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();
// 可以顺利执行

最后我们通过异步函数+调用util模块的promisify构造函数来依次读取1.txt、2.txt、3.txt文件

const fs = require('fs');
// 改造现有异步函数api，让其返回promise对象，从而支持异步函数语法
const promisify = require('util').promisify;
// 调用promisify方法改造现有异步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, r2, r3);
    
}
run();