nodeJS中promise对象对结果简便输出办法(建议使用异步终极方案 async+await)

一、promise对象利用all()方法实现简洁输出

const fs = require("fs");
const path = require("path");
const util = require("util");
​
let filePath1 = path.join(__dirname, "files", "1.txt");
let filePath2 = path.join(__dirname, "files", "2.txt");
let filePath3 = path.join(__dirname, "files", "3.txt");
let filePath4 = path.join(__dirname, "files", "data.txt");
​
let readFilePromise = util.promisify(fs.readFile);  //这一句代码相当于下面的整个函数的代码
let writeFilePromise = util.promisify(fs.writeFile);
​
Promise.all([readFilePromise(filePath1,"utf-8"), readFilePromise(filePath2,"utf-8"),readFilePromise(filePath3,"utf-8")]).then((data)=>{
    let str1 = data.join("");
    writeFilePromise(filePath4,str1);
}).catch((error)=>{
    //只要执行p1,p2时其中一个报错,就会执行这里的代码
    console.log(error);
});

1.1、async+await版本()

const fs = require("fs");
const path = require("path");
const util = require("util");
let filePath1 = path.join(__dirname, "files", "1.txt");
let filePath2 = path.join(__dirname, "files", "2.txt");
let filePath3 = path.join(__dirname, "files", "3.txt");
let filePath4 = path.join(__dirname, "files", "data.xt");
let readFile = util.promisify(fs.readFile);
let writeFile = util.promisify(fs.writeFile);
async function func() {
    let data1 = await readFile(filePath1, "utf-8");
    let data2 = await readFile(filePath2, "utf-8");
    let data3 = await readFile(filePath3, "utf-8");
    console.log(data1+data2+data3);
    writeFile(filePath4, data1+data2+data3)
}
func();

async+await版本()对于输出的结果有一个便捷度处理程序,利用await关键字使得promise对象直接获取其中的resolve参数赋值给一个变量,我们将变量拼接起来,就可以实现拼接的效果。

二、Promise的常用其他方法(针对于then()链式方法)

2.1、promise对象catch()方法和finally()方法,在then()方法链式拼接实现错误输出。

以及finally()方法承诺成功与失败都会执行这里的代码

//一般,我们会把以下代码:
p1.then((data1)=>{
    console.log("承诺成功", data1);
},(error1)=>{
    console.log("承诺失败", error1);
});
​
//写成
p1.then((data1)=>{
    console.log("承诺成功", data1);
}).catch((error1)=>{
    console.log("承诺失败", error1);
}).finally(()=>{
    console.log("承诺成功与失败都会执行这里的代码");
});
​

2.2、Promise类的all() 方法实现简洁输出

参数:是一个数组,数组元素是Promise实例对象,只有数组里面所有的Promise成功了,则才会执行 then 第一个回调

语法结构:

就是将数组里面的值都存入到一个变量当中去,利用数组的拼接实现结果都输出

Promise.all([p1,p2]).then((data)=>{}

const fs = require("fs");
const path = require("path");
​
let filePath1 = path.join(__dirname, "files", "1.txt");
let filePath2 = path.join(__dirname, "files", "2.txt");
​
​
let p1 = new Promise((resolve, reject)=>{
    //1、同步代码
    // console.log("同步代码");
​
    // pending(进行中)、fulfilled(已成功)和rejected(已失败)
    //2、异步代码
    fs.readFile(filePath1,"utf-8",(error1, data1)=>{
        if(error1){
            //失败的时候做的事情
            reject(error1);
        }
        //读取完之后做的事情
        resolve(data1)
    })
});
let p2 = new Promise((resolve, reject)=>{
    //1、同步代码
    // console.log("同步代码");
​
    // pending(进行中)、fulfilled(已成功)和rejected(已失败)
    //2、异步代码
    fs.readFile(filePath2,"utf-8",(error1, data1)=>{
        if(error1){
            //失败的时候做的事情
            reject(error1);
        }
        //读取完之后做的事情
        resolve(data1)
    })
});
​
Promise.all([p1,p2]).then((data)=>{
    // data是一个数组,分别是p1和p2最后传来的数据
    console.log(data); // [ '我', '爱' ]
    console.log(data.join(""));  // 我爱
}).catch((error)=>{
    //只要执行p1,p2时其中一个报错,就会执行这里的代码
    console.log(error);
});

2.3、Promise类的race() 方法

参数:是一个数组,数组元素是Promise实例对象,只要数组里面的任何一个Promise成功了,则才会执行 then 第一个回调,且只执行1次。

const fs = require("fs")
const path = require("path")
const util = require('util');
​
let filePath1 = path.join(__dirname, "files", "1.txt") 
let filePath2 = path.join(__dirname, "files", "2.txt") 
​
let readFilePromise = util.promisify(fs.readFile);
​
let p1 = readFilePromise(filePath1,"utf-8")
let p2 = readFilePromise(filePath2,"utf-8")
Promise.race([p1,p2]).then((data)=>{
    // p1,p2只要其中一个执行完,就会执行一遍这里的代码,且这里的代码只会执行1次
    console.log(123);
    console.log(data);
});
​
//123
//我

33、异步终极方案 async+await

33.1、async+await基本结构

之前我么写过类似一下的代码:

function func(a, b) {
    return a + b
}
​
let ret = func(10, 30);
let ret1 = func(50, 320);
let ret2 = func(1560, 30);
let ret3 = func(10, 3560);
console.log(ret + ret1 + ret2 + ret3);

如果Promise对象也能有对应的方式来接收,写成类似:

let data1 = await readfilePromise;  // 直接获取成功的数据

async的最终格式如下:

async function func() {
    let data1 = await promise对象1;
    let data2 = await promise对象2;
    let data3 = await promise对象3;
}
// 相当于让异步函数对象1先执行完毕之后,再执行异步函数对象2,再执行异步函数对象3

案例见 2.5

3.2、注意事项

  1. 如果await后面只写一个基本数据类型,会这个基本数据类型进行包装,包装成一个 Promise 对象

async function func() {
    let data1 = await 123;
    //1. await后面只写一个基本数据类型 会这个基本数据类型进行包装,包装成一个 Promise 对象
    // 即data1相当于: new Promise((resolve,reject)=>{resolve(123)})
​
    console.log("data1:", data1);   //data1: 123
​
    return data1
    // return await data1
​
}
​
let a = func();
​
a.then((data)=>{
    console.log(data);  //123  接收到上面的返回值Promise对象的执行结果
});
  1. 如果await后面是一个 Promise,会把 resolve 的值返回

  2. async 函数里面的 await 是异步的,不是同步

async function func() {
    console.log("start-------");
    let data1 = await readFile(filePath1, "utf-8");
    console.log("end-----------");
    let data2 = await readFile(filePath2, "utf-8");
    let data3 = await readFile(filePath3, "utf-8");
​
    console.log(data1+data2+data3);
}
​
console.log("start");
func();
console.log("end");
​
//输出结果依次为:
//start
//start-------
//end
//end-----------
  1. 错误处理(外部处理)

async function func() {
    let data1 = await readFile(filePath1, "utf-8");
    let data2 = await readFile(filePath2, "utf-8");
    let data3 = await readFile(filePath3, "utf-8");
​
    console.log(data1+data2+data3);
​
    // writeFile(filePath4, data1+data2+data3)
}
​
func().catch( error => {
    console.log(error);
} ).finally(()=>{
    console.log("finally");
});
  1. 错误处理(内部处理)

async function func() {
    try{
        let data1 = await readFile(filePath1, "utf-8");
        let data2 = await readFile(filePath2, "utf-8");
        let data3 = await readFile(filePath3, "utf-8");
    }
    catch (error) {
        console.log(error);
        return
    }
    finally {
        console.log("finally");
    }
​
    console.log("end");
}
​
func();

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值