ES6模块化与异步编程高级用法

一、ES6模块化

1.node.js实现模块化

node.js遵循CommonJS的模块化规范。其中：导入其他模块使用require()方法；模块对外共享成员使用module.exports对象。模块化的优点：降低沟通成本，极大的方便了各个模块之间的调用。

2.前端模块化规范的分类

在ES6规范诞生之前，JS已经尝试并提出AMD,CMD,CommomJS等模块化规范。**但是，这些模块化存在差异性，局限性，并不是浏览器与服务器通用的模块化标准。**例：AMD,CMD适用于浏览器端JS模块化；CommomJS适用于服务器端JS模块化。

3.ES6模块化规范中的定义

1.每个js文件都是独立的模块；
2.导入其他模块成员使用import关键字；
3.向外共享模块成员使用export。

4.ES6模块化的基本语法

ES6的模块化主要包括3种方法：
1.默认导出与默认导入；
注意：1.每个模块中，只允许使用一次export default ，否则会报错。2.默认导入时接收名称可以任意名称，只要是合法成员名称即可。

//默认导出
//定义模块化私有成员
let a = 10;
let b = 10;
//定义模块化私有方法show
function show() { }
// 使用export default 默认导出语法，向外共享a和show两个成员
export default {
  a,
  show,
};

//默认导入
// 从  01.默认导出.js  模块中导入export default向外共享的成员
import m from "./01.默认导出.js";

console.log(m); //结果：{ n1: 10, show: [Function: show] }

2.按需导出与导入；
注意：
每个模块可以多次按需导出；
按需导入的成员名称必须和按需导出的名称保持一致；
按需导入时，可以使用as关键字进行重命名；
按需导入可以和默认导入一起使用。

//语法： export 按需导出的成员
//按需导出变量a，b
export let a = "0";
export let b = "1";
export function say() {}

//语法： import { s1 } from '模块标识符'
import info, { a, b, say } from "./03.按需导出.js";
console.log(a);//0
console.log(b);//1
console.log(say)//[Function: say]
console.log(info)//{ c: 20 }

3.直接导入并执行模块中的代码。
如果只想单纯的执行某个模块中的代码，并不需要得到模块中的向外共享的成员。此时，可以直接导入并执行模块代码。

for (let i = 0; i < 3; i++) {
  console.log(i)
}
// 直接导入并执行
import "./05.直接运行模块中的代码.js";

二、Promise

1.回调地狱

多层回调函数的互相嵌套，就形成回调地狱。
缺点：1.代码耦合性太强，难以维护；2.大量冗余代码相互嵌套，代码可读性变差。
解决办法：ES6新增的Promise。

2.基本概念

1. Promise 是一个构造函数： 我们可以创建 Promise 的实例 const p = new Promise()，new 出来的 Promise 实例对象，代表一个异步操作。 2.Promise.prototype 上包含一个 .then() 方法： 每一次 new Promise() 构造函数得到的实例对象，都可以通过原型链的方式访问到 .then() 方法，例如 p.then()。 3. .then() 方法用来预先指定成功和失败的回调函数： p.then(成功的回调函数，失败的回调函数)，p.then(result => { }, error => { })，调用 .then() 方法时，成功的回调函数是必选的、失败的回调函数是可选的。

3、基于 then-fs读取文件内容

安装 then-fs 这个第三方包，从而支持我们基于 Promise 的方式读取文件的内容：

//运行命令
npm i then-fs

3.1、 then-fs 的基本使用

调用 then-fs 提供的 readFile() 方法，可以异步地读取文件的内容，它的返回值是 Promise 的实例对象。因
此可以调用 .then() 方法为每个 Promise 异步操作指定成功和失败之后的回调函数。示例代码如下：

import thenFs from "then-fs";
thenFs.readFile("./files/1.txt", "utf8").then((r1) => {
  console.log(r1);
});
thenFs.readFile("./files/2.txt", "utf8").then((r1) => {
  console.log(r1);
});
thenFs.readFile("./files/3.txt", "utf8").then((r1) => {
  console.log(r1);
});

.then() 方法中返回了一个新的 Promise 实例对象，则可以通过下一个 .then() 继续进行处理。通
过 .then() 方法的链式调用，就解决了回调地狱的问题

3.2、.catch 捕获错误

在 Promise 的链式操作中如果发生了错误，可以使用 Promise.prototype.catch 方法进行捕获和处理；如果不希望前面的错误导致后续的 .then 无法正常执行，则可以将 .catch 的调用提前：（示例：）

import thenFs from "then-fs";
thenFs
  .readFile("./files/11.txt", "utf8") //返回promise对象
  //捕获错误，并输出。错误被及时处理，不影响后续.then执行
  .catch((err) => console.log(err))
  .then((r1) => {
    console.log(r1);
    return thenFs.readFile("./files/2.txt", "utf8");
  })
  .then((r2) => {
    console.log(r2);
    return thenFs.readFile("./files/3.txt", "utf8");
  })
  .then((r3) => {
    console.log(r3);
    return "00"; //字符串
  })
  .then((r4) => {
    console.log(r4);
  });
  //末尾，捕获错误，并输出。影响后续.then执行
// .catch((err) => console.log(err));

3.3、 Promise.race() 方法

Promise.race() 方法会发起并行的 Promise 异步操作，只要任何一个异步操作完成，就立即执行下一步的。
.then 操作（赛跑机制）

import thenFs from "then-fs";
const promiseArr = [
  thenFs.readFile("./files/1.txt", "utf8"),
  thenFs.readFile("./files/2.txt", "utf8"),
  thenFs.readFile("./files/3.txt", "utf8"),
];
// 只返回一个结果
 Promise.race(promiseArr).then((result) => {
  console.log(result);
 });
// 返回所有结果
Promise.all(promiseArr).then((result) => {
  console.log(result);
});

4、 基于 Promise 封装读文件的方法

方法的封装要求：
1.方法名称要定义为getfile；
2.方法接收一个形参fpath，表示要读取的文件路径；
3.方法的返回值为Promise实例对象。

调用 resolve 和 reject 回调函数：

import fs from "fs";
function getFile(fpath) {
  return new Promise((resolve, rejects) => {
    fs.readFile(fpath, "utf-8", (err, data) => {
      if (err) {
        return rejects(err);//读取失败，调用失败的回调函数
      }
      resolve(data);//读取成功，调用成功的回调函数
    });
  });
}

getFile("./files/11.txt")
  // .then((r1) => {'成功的回调函数','失败的回调函数')
  .then(
    (r1) => {
      console.log(r1);
    },
    (err) => {
      console.log(err.message);
    }
  );

代码中的new Promise()只是创建了一个形式上的异步操作，创作具体的异步操作需要在new Promise()构造函数中传递一个function函数，将具体的操作定义到function函数内部；.then()指定的成功和失败的回调函数，可以在function的形参中进行接收；Promise异步操作的结果，可以调用resolve或reject回调函数惊醒处理。

三、async/await

1、 什么是 async/await

async/await是ES8引入的新语法，用来简化Promise操作步骤。在async/await出现之前，开发者只能通过链式.then()的方法处理Promise异步操作。
注意：1.如果在function中使用await，则function必须被async修饰。2.在async方法中，第一个await之后的代码会异步操作执行。

import thenFs from "then-fs";
console.log("A");
async function getFileAll() {
  console.log("B");
  const r1 = await thenFs.readFile("./files/1.txt", "utf8");
  console.log(r1);
  console.log("C");
}
getFileAll();
console.log("D");
/* 执行结果：
A
B
D
111
C
*/

四、Eventloop

1、 同步任务、异步任务、EventLoop（事件循环）

为了防止某个耗时任务导致程序假死的问题，JavaScript 把待执行的任务分为了两类：
同步任务(synchronous）:又叫做非耗时任务，指的是在主线程上排队执行的那些任务;只有前一个任务执行完毕，才能执行后一个任务。
异步任务（asynchronous）：又叫做耗时任务，异步任务由 JavaScript 委托给宿主环境进行执行；当异步任务执行完成后，会通知 JavaScript 主线程执行异步任务的回调函数。
EventLoop：JavaScript 主线程从“任务队列”中读取异步任务的回调函数，放到执行栈中依次执行。这个过程是循环不断的，所以整个的这种运行机制又称为 EventLoop（事件循环）。

五、宏任务和微任务

1、 什么是宏任务和微任务

JavaScript 把异步任务又做了进一步的划分，异步任务又分为两类，分别是：
宏任务（macrotask）：异步Ajax请求、setTimeout、setInterval、文件操作、其他红任务。每一个宏任务执行完之后，都会检查是否存在待执行的微任务，如果有，则执行完所有微任务之后，再继续执行下一个宏任务。
微任务（microtask）：Promise.then、.catch、和.finally、process.nextTick、其它微任务。