JavaScript详解使用Promise处理回调地狱与async await修饰符

// 将读取的a、b、c里面的内容，按照顺序输出
const fs = require('fs');
// 读取a文件
fs.readFile('./a.txt','utf-8',(err,data)=>{
    if(err) throw err;
    console.log(data);
    // 读取b文件
    fs.readFile('./b.txt','utf-8',(err,data)=>{
       	if(err) throw err;
        console.log(data);
        // 读取c文件
        fs.readFile('./c.txt','utf-8',(err,data)=>{
            if(err) throw err;
            console.log(data)
        })
    })
})

// 实例化一个Promise，表示定义一个容器，需要给它传递一个函数作为参数，而该函数又有两个形参，通常用resolve和reject表示。该函数里面可以写异步请求的代码
// 换个角度，也可以理解为定下了一个承诺诺
let p = new Promise((resolve,reject)=>{
    // 形参resolve，单词意思是 完成
    // 实参reject，单词意思是 失败
    fs.readFile('./a.txt','utf-8',(err,data)=>{
        if(err){
            // 失败，就告诉别人，承诺失败了
            reject(err);
        }else{
            // 成功，就告诉别人，承诺实现了
            resolve(data);
        }
    }
})

// 通过调用 p 的then方法，可以获取到上述 "承诺" 的结果
// then方法有两个函数类型的参数，参数1表示承诺成功时调用的函数，参数2可选，表示承诺失败时调用的函数
// p.then(
//	(data)=>{},  // 函数类型的参数，用于获取承诺成功后的数据
//   (err)=>{}   // 函数类型的参数，用于承诺失败后的错误信息
//)
p.then(
	(data)=>{
        console.log(data);
    },
    (err)=>{
        console.log(err);
    }
)

const fs = require('fs');
// 1.创建Promise对象：(承诺)
let p = new Promise((resolve,reject)=>{
    resolve(123);
    resolve(456);  // 这次的调用无效
});
// 2.获取异步任务的结果
// p.then(函数1，[函数2]);
p.then(res =>{
    console.log(res);  // 123
},err =>{
    console.log(err);
})

const fs = require('fs');
// promise 承诺
let p1 = new Promise((resolve, reject) => {
  fs.readFile('./a.txt', 'utf-8', (err, data) => {
    err ? reject(err) : resolve(data.length);
  });
});
let p2 = new Promise((resolve, reject) => {
  fs.readFile('./b.txt', 'utf-8', (err, data) => {
    err ? reject(err) : resolve(data.length);
  });
});
let p3 = new Promise((resolve, reject) => {
  fs.readFile('./c.txt', 'utf-8', (err, data) => {
    err ? reject(err) : resolve(data.length);
  });
});
p1.then(a => {
  console.log(a);
  return p2;
}).then(b => {
  console.log(b);  	// 接收上面传递的值p2
  return p3;
}).then(c => {
  console.log(c)   	// 接收上面传递的值p3
}).catch((err) => {
  console.log(err);   // 如果错误，打印报错信息
});

function myReadFile(path) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, 'utf-8', (err, data) => {
            err ? reject(err) : resolve(data.length);
        })
    });
}
myReadFile('./a.txt')
.then(a => {
  console.log(a);
  return myReadFile('./b.txt');
})
.then(b => {
  console.log(b);
  return myReadFile('./c.txt');
})
.then(c => {
  console.log(c)
})
.catch((err) => {
  console.log(err);
});

// then-fs 模块是第三方模块，需要 npm install then-fs  下载安装的
const fs = require('then-fs');
// then-fs 对内置的fs模块进行了重写的封装。调用方法后，返回Promise对象
let p1 = fs.readFile('./files/a.txt', 'utf-8');  // 
let p2 = fs.readFile('./files/b.txt', 'utf-8');
let p3 = fs.readFile('./files/c.txt', 'utf-8');
// 通过then获取结果
p1.then(res => {
  console.log(res.length);
  return p2;
}).then(res => {
  console.log(res.length);
  return p3;
}).then(res => {
  console.log(res.length);
})

const fs = require('fs');
// 将异步读取文件的代码封装
function myReadFile (path) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, 'utf-8', (err, data) => {
            err ? reject(err) : resolve(data.length);
        });
    }).catch(err => {
        console.log(err);
    });
}
async function abc () {
    let a = await myReadFile('./a.txt');
    let b = await myReadFile('./b.txt');
    let c = await myReadFile('./c.txt');
    console.log(b);
    console.log(a);
    console.log(c);
}
abc();

let fs = require('fs');
let p1 = new Promise('./files/a.txt','utf-8');
let p2 = new Promise('./files/bbb.txt','utf-8');  // 注意：这里故意写错路径
let p3 = new Promise('./files/c.txt','utf-8');

// ----------------------------通过 then 获取结果-----------------------------
p1.then(res=>{
    console.log(res);
    return p2;
}).then(res=>{
    console.log(res);
    return p3
}).catch(err=>{
    console.log(err);
})

// ---------------------------通过 async/await 获取结果--------------------
async function abc(){
    try{  // 尝试做一些事情
        let r1 = await p1;  // 正常获取结果
        let r2 = await p2;  // 这里出错了，就会抛出错误 throw err.
        let r3 = await p3;
        console.log(r1,r2,r3)
    }catch(e){
        console.log(e);  // catch这里，会抓住前面try里面抛出的错误
    }
}
abc();