一、Promise 的基本使用

1.1、Promise 简介

Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大。它由社区最早提出和实现，ES6 将其写进了语言标准，统一了用法，原生提供了Promise对象。

所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果。从语法上说，Promise 是一个对象，从它可以获取异步操作的消息。Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理。

Promise对象有以下两个特点。

（1）对象的状态不受外界影响。Promise对象代表一个异步操作，有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise这个名字的由来，它的英语意思就是“承诺”，表示其他手段无法改变。

（2）一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为 resolved（已定型）。如果改变已经发生了，你再对Promise对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。

1.2、Promise 的基本使用

新建的Promise就是一个容器，里面可以存放异步操作，也可以存放同步操作

  1. const fs = require("fs");
  2. const path = require("path");
  4. let filePath = path.join(__dirname, "files", "3.txt");
  6. // 异步操作可能成功或者失败
  7. // 第一个形参resolve ， 成功的时候执行的函数
  8. // 第二个形参reject ， 失败的时候执行的函数
  9. let p1 = new Promise((resolve, reject)=>{
  10.     //1、同步代码
  11.     console.log("同步代码");
  13.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  14.     //2、异步代码
  15.     fs.readFile(filePath,"utf-8",(error1, data1)=>{
  16.         if(error1){
  17.             //失败的时候做的事情
  18.             reject(error1)；    // 调用后面p1.then的第二个函数
  19.         }
  20.         //读取完之后做的事情
  21.         resolve(data1)；    // 调用后面p1.then的第二个函数
  22.     })
  23. });
  25. p1.then((data1)=>{
  26.     console.log("读取成功", data1);
  27. },(error1)=>{
  28.     console.log("读取失败", error1);
  29. });

1.3、Promise的then链式调用的特点

链式调用的特点：
1、第一个then执行完会执行第二个then
2、then里面的函数的返回值，会被下一个then的形参接收
3、如果返回的是一个promise对象，下一个then的形参接收到的不是这个promise对象，而是这个promise对象内部调用resolve时候的实际参数

  1. const fs = require("fs");
  2. const path = require("path");
  4. let filePath = path.join(__dirname, "files", "3.txt");
  6. // 新建的Promise就是一个容器，里面可以存放异步操作，也可以存放同步操作
  8. // 异步操作可能成功或者失败
  9. // 第一个形参resolve ， 成功的时候执行的函数
  10. // 第二个形参reject ， 失败的时候执行的函数
  11. let p1 = new Promise((resolve, reject)=>{
  12.     //1、同步代码
  13.     // console.log("同步代码");
  15.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  16.     //2、异步代码
  17.     fs.readFile(filePath,"utf-8",(error1, data1)=>{
  18.         if(error1){
  19.             //失败的时候做的事情
  20.             reject(error1)
  21.         }
  22.         //读取完之后做的事情
  23.         resolve("resolve的形参")
  24.     })
  25. });
  27. //业内把promise then的写法被称为开火车开发
  29. p1.then((data1)=>{
  30.     return p1
  31. },(error1)=>{
  32.     console.log("读取失败", error1);
  33.     return error1
  34. }).then((data)=>{
  35.     console.log(data);   // “resolve("resolve的形参")
  36. });

二、使用promise实现之前文件读取的案例

2.1、基础版

  1. //基础版
  2. const fs = require("fs");
  3. const path = require("path");
  5. let filePath1 = path.join(__dirname, "files", "1.txt"); // 我
  6. let filePath2 = path.join(__dirname, "files", "2.txt"); // 爱
  7. let filePath3 = path.join(__dirname, "files", "3.txt"); // Node.js
  10. let p1 = new Promise((resolve, reject)=>{
  11.     //1、同步代码
  12.     // console.log("同步代码");
  14.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  15.     //2、异步代码
  16.     fs.readFile(filePath1,"utf-8",(error1, data1)=>{
  17.         if(error1){
  18.             //失败的时候做的事情
  19.             reject(error1);
  20.         }
  21.         //读取完之后做的事情
  22.         resolve(data1)
  23.     })
  24. });
  25. let p2 = new Promise((resolve, reject)=>{
  26.     //1、同步代码
  27.     // console.log("同步代码");
  29.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  30.     //2、异步代码
  31.     fs.readFile(filePath2,"utf-8",(error1, data1)=>{
  32.         if(error1){
  33.             //失败的时候做的事情
  34.             reject(error1);
  35.         }
  36.         //读取完之后做的事情
  37.         resolve(data1)
  38.     })
  39. });
  40. let p3 = new Promise((resolve, reject)=>{
  41.     //1、同步代码
  42.     // console.log("同步代码");
  44.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  45.     //2、异步代码
  46.     fs.readFile(filePath3,"utf-8",(error1, data1)=>{
  47.         if(error1){
  48.             //失败的时候做的事情
  49.             reject(error1)
  50.         }
  51.         //读取完之后做的事情
  52.         resolve(data1)
  53.     })
  54. });
  56. let str1 = "";
  58. p1.then((data)=>{
  59.     str1+=data;
  60.     return p2
  61. },(error1)=>{
  62.     console.log("读取文件1失败", error1);
  63.     return error1
  64. }).then((data)=>{
  65.     str1+=data;
  66.     return p3;
  67. }).then((data)=>{
  68.     str1+=data;
  69.     console.log(str1);
  70. });

2.2、封装函数版

  1. const fs = require("fs");
  2. const path = require("path");
  4. let filePath1 = path.join(__dirname, "files", "1.txt");
  5. let filePath2 = path.join(__dirname, "files", "2.txt");
  6. let filePath3 = path.join(__dirname, "files", "3.txt");
  8. function readFilePromise(filePath){
  9.     return new Promise((resolve, reject)=>{
  11.         fs.readFile(filePath,"utf-8",(error1, data1)=>{
  12.             if(error1){
  13.                 //失败的时候做的事情
  14.                 reject(error1);
  15.             }
  16.             //读取完之后做的事情
  17.             resolve(data1)
  18.         })
  19.     });
  20. }
  22. let str1 = "";
  24. readFilePromise(filePath1).then((data)=>{
  25.     str1+=data;
  26.     return readFilePromise(filePath2)
  27. },(error1)=>{
  28.     console.log("读取文件1失败", error1);
  29.     return error1
  30. }).then((data)=>{
  31.     str1+=data;
  32.     return readFilePromise(filePath3);
  33. }).then((data)=>{
  34.     str1+=data;
  35.     console.log(str1);
  36. });

2.3、util版本

node中有一个util工具模块下，有一个promisify方法，这个方法相当于封装了一个返回promise对象的函数。

文档网址：http://nodejs.cn/api/util.html#util_util_promisify_original

传入一个遵循常见的错误优先的回调风格的函数（即以 (err, value) => ... 回调作为最后一个参数），并返回一个返回 promise 的版本。

  1. let readFilePromise = util.promisify(fs.readFile);  //这一句代码相当于下面的整个函数的代码
  2. // function readFilePromise(filePath){
  3. //     return new Promise((resolve, reject)=>{
  4. //
  5. //         fs.readFile(filePath,"utf-8",(error1, data1)=>{
  6. //             if(error1){
  7. //                 //失败的时候做的事情
  8. //                 reject(error1);
  9. //             }
  10. //             //读取完之后做的事情
  11. //             resolve(data1)
  12. //         })
  13. //     });
  14. // }
  16. // 总结 ：util.promisify(fs.readFile) 得到一个promise对象

完整代码：

  1. const fs = require("fs");
  2. const path = require("path");
  3. const util = require("util");
  5. let filePath1 = path.join(__dirname, "files", "1.txt");
  6. let filePath2 = path.join(__dirname, "files", "2.txt");
  7. let filePath3 = path.join(__dirname, "files", "3.txt");
  8. let filePath4 = path.join(__dirname, "files", "data.txt");
  10. let readFilePromise = util.promisify(fs.readFile); 
  11. let writeFilePromise = util.promisify(fs.writeFile);
  13. let str1 = "";
  15. readFilePromise(filePath1).then((data)=>{
  16.     str1+=data;
  17.     return readFilePromise(filePath2)
  18. },(error1)=>{
  19.     console.log("读取文件1失败", error1);
  20.     return error1
  21. }).then((data)=>{
  22.     str1+=data;
  23.     return readFilePromise(filePath3);
  24. }).then((data)=>{
  25.     str1+=data;
  26.     console.log(str1);
  27.     writeFilePromise(filePath4, str1);
  28. });

2.4、all版本

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

2.5、async+await版本

  1. const fs = require("fs");
  2. const path = require("path");
  3. const util = require("util");
  5. let filePath1 = path.join(__dirname, "files", "1.txt");
  6. let filePath2 = path.join(__dirname, "files", "2.txt");
  7. let filePath3 = path.join(__dirname, "files", "3.txt");
  8. let filePath4 = path.join(__dirname, "files", "data.txt");
  10. let readFile = util.promisify(fs.readFile);
  11. let writeFile = util.promisify(fs.writeFile);
  13. async function func() {
  14.     let data1 = await readFile(filePath1, "utf-8");
  15.     let data2 = await readFile(filePath2, "utf-8");
  16.     let data3 = await readFile(filePath3, "utf-8");
  18.     console.log(data1+data2+data3);
  20.     writeFile(filePath4, data1+data2+data3)
  21. }
  23. func();

三、Promise的常用其他方法

3.1、promise对象catch()方法和finally()方法

  1. //一般，我们会把以下代码：
  2. p1.then((data1)=>{
  3.     console.log("承诺成功", data1);
  4. },(error1)=>{
  5.     console.log("承诺失败", error1);
  6. });
  8. //写成
  9. p1.then((data1)=>{
  10.     console.log("承诺成功", data1);
  11. }).catch((error1)=>{
  12.     console.log("承诺失败", error1);
  13. }).finally(()=>{
  14.     console.log("承诺成功与失败都会执行这里的代码");
  15. });

3.2、Promise类的all() 方法

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

  1. const fs = require("fs");
  2. const path = require("path");
  4. let filePath1 = path.join(__dirname, "files", "1.txt");
  5. let filePath2 = path.join(__dirname, "files", "2.txt");
  8. let p1 = new Promise((resolve, reject)=>{
  9.     //1、同步代码
  10.     // console.log("同步代码");
  12.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  13.     //2、异步代码
  14.     fs.readFile(filePath1,"utf-8",(error1, data1)=>{
  15.         if(error1){
  16.             //失败的时候做的事情
  17.             reject(error1);
  18.         }
  19.         //读取完之后做的事情
  20.         resolve(data1)
  21.     })
  22. });
  23. let p2 = new Promise((resolve, reject)=>{
  24.     //1、同步代码
  25.     // console.log("同步代码");
  27.     // pending（进行中）、fulfilled（已成功）和rejected（已失败）
  28.     //2、异步代码
  29.     fs.readFile(filePath2,"utf-8",(error1, data1)=>{
  30.         if(error1){
  31.             //失败的时候做的事情
  32.             reject(error1);
  33.         }
  34.         //读取完之后做的事情
  35.         resolve(data1)
  36.     })
  37. });
  39. Promise.all([p1,p2]).then((data)=>{
  40.     // data是一个数组，分别是p1和p2最后传来的数据
  41.     console.log(data); // [ '我', '爱' ]
  42.     console.log(data.join(""));  // 我爱
  43. }).catch((error)=>{
  44.     //只要执行p1,p2时其中一个报错，就会执行这里的代码
  45.     console.log(error);
  46. });

3.3、Promise类的race() 方法

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

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

四、async+await

4.1 async+await 终极版

看下面这一段代码：

  1. function func(a, b) {
  2.     return a + b
  3. }
  5. let ret = func(10, 30);
  6. let ret1 = func(50, 320);
  7. let ret2 = func(1560, 30);
  8. let ret3 = func(10, 3560);
  9. console.log(ret + ret1 + ret2 + ret3);

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

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

async 的最终格式如下：

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

4.2、注意事项

  1. 如果await后面只写一个基本数据类型，会这个基本数据类型进行包装，包装成一个 Promise 对象
  1. async function func() {
  2.     let data1 = await 123;
  3.     //1. await后面只写一个基本数据类型 会这个基本数据类型进行包装，包装成一个 Promise 对象
  4.     // 即data1相当于： new Promise((resolve,reject)=>{resolve(123)})
  6.     console.log("data1:", data1);   //data1: 123
  8.     return data1
  9.     // return await data1
  11. }
  13. let a = func();
  15. a.then((data)=>{
  16.     console.log(data);  //123  接收到上面的返回值Promise对象的执行结果
  17. });
  1. 如果await后面是一个 Promise，会把 resolve 的值返回
  2. async 函数里面的 await 是异步的，不是同步
  1. async function func() {
  2.     console.log("start-------");
  3.     let data1 = await readFile(filePath1, "utf-8");
  4.     console.log("end-----------");
  5.     let data2 = await readFile(filePath2, "utf-8");
  6.     let data3 = await readFile(filePath3, "utf-8");
  8.     console.log(data1+data2+data3);
  9. }
  11. console.log("start");
  12. func();
  13. console.log("end");
  15. //输出结果依次为：
  16. //start
  17. //start-------
  18. //end
  19. //end-----------
  1. 错误处理(外部处理)
  1. async function func() {
  2.     let data1 = await readFile(filePath1, "utf-8");
  3.     let data2 = await readFile(filePath2, "utf-8");
  4.     let data3 = await readFile(filePath3, "utf-8");
  6.     console.log(data1+data2+data3);
  8.     // writeFile(filePath4, data1+data2+data3)
  9. }
  11. func().catch( error => {
  12.     console.log(error);
  13. } ).finally(()=>{
  14.     console.log("finally");
  15. });
  1. 错误处理(内部处理)
  1. async function func() {
  2.     try{
  3.         let data1 = await readFile(filePath1, "utf-8");
  4.         let data2 = await readFile(filePath2, "utf-8");
  5.         let data3 = await readFile(filePath3, "utf-8");
  6.     }
  7.     catch (error) {
  8.         console.log(error);
  9.         return
  10.     }
  11.     finally {
  12.         console.log("finally");
  13.     }
  15.     console.log("end");
  16. }
  18. func();