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

ES6模块化

回顾：node.js中如何实现模块化

node.js遵守了CommonJS的模块化规范。其中：

• 导入其他模块使用require()方法
• 模块对外共享成员使用module.exports对象

模块化的好处：
大家都遵守同样的模块化规范写代码，降低了沟通成本，极大方便了各个模块之间的相互调用，利人利己。

前端模块化规范的分类

在E6模块化规范诞生之前，JavaScript社区已经尝试并提出了AMD、CMD、CommonJS等模块化规范。

但是，这些由社区提出的模块化标准，还是存在一定的差异性与局限性、并不是浏览器与服务器通用的模块化标准，例如：

• AMD和CMD适用于浏览器端的JavaScript模块化

• CommonJS适用于服务器端的JavaScript模块化

太多的模块化规范给开发者增加了学习的难度与开发的成本。因此，大一统的ES6模块化规范诞生了！与开发的成本。因此，大一统的ES6模块化规范诞生了！

什么是ES6模块化规范

ES6模块化规范是浏览器与服务器端通用的模块化开发规范。它的出现极大的降低了前端开发者的模块化学习成本，开发者不需要再额外学习AMD、CMD或CommonJS等模块化规范。

ES6模块化规范中定义：

• 每个js文件都是一个独立的模块
• 导入其他模块成员使用import关键字
• 向外贡献模块成员使用export关键字
  
  

在node.js中体验ES6模块化

node.js中默认仅支持CommonJs模块化规范，若想基于node.js体验与学习ES6的模块化语法，可以按照如下两个步骤进行配置：

• ① 确保安装了 v14.15.1 或更高版本的node.js

• ② 在package.json 的根节点中添加"type":"module"节点

ES6模块化的基本语法

ES6的模块化主要包含如下3种用法：

• ① 默认导出与默认导入
• ② 按需导出与按需导入
• ③ 直接导入并执行模块中的代码
  
  

默认导出

默认导出的语法：export default 默认导出的成员

let n1 = 10 // 定义模块私有成员 n1
let n2 = 20 // 定义模块私有成员 n2（外界访问不到n2，因为它没有共享出去）
function show(){}  // 定义模块私有方法 show

export default{ // 使用 export default 默认导出语法，向外共享 n1 和 show两个成员
    n1,
    show
}

默认导入

默认导入的语法：import 接收名称 from '标识符'

// 从01_m1.js模块中导入 export default 向外共享成员
// 并使用 m1成员进行接收
import m1 from './01_m1.js'

// 打印输出的结果为：
// {n1:10,show:[Function:show]}
console.log(m1)

默认导出的注意事项

每个模块中，只允许使用唯一的一次 export default，否则会报错！

默认导入的注意事项

默认导入是接收名称可以是任意名称，只要是合法的成员名称即可：

// m1 是合法的名称
import m1 from './01_m1.js'

// 123m 不是合法的名称，因为成员名称不能以数字开头
import 123m from './01_m1.js'

按需导出

按需导出的语法：export 按需成员

// 当前模块为03_m2.js

// 向外按需导出变量 s1
export let s1 = 'aaa'

// 向外按需导出变量 s2
export let s2 = 'ccc'

// 向外按需导出方法 say
export function say(){}

按需导入

按需导入的语法：import {s1} from '模块标识符'

// 导入模块成员
import { s1, s2, say }from './03_m2.js'

console.log(s1) // 打印输出 aaa
console.log(s2) // 打印输出 ccc
console.log(say)// 打印输出[Function:say]

按需导出与按需导入的注意事项

• ① 每个模块中可以使用多次按需导出

• ② 按需导入的成员名称必须和按需导出的名称保持一致

• ③ 按需导入时，可以使用as关键字进行重命名

• ④ 按需导入可以和默认导入一起使用
  
  

直接导入并执行模块中的代码

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

// 当前文件模块为05_m3.js

// 在当前模块中执行一个 for 循环操作
for(let i = 0 ;i < 3;i++){
    console.log(i)
}

// 直接导入并执行模块代码，不需要得到模块向外共享的成员
import './05_m3.js'

Promise

回调地狱

多层回调函数的相互嵌套，就形成了回调地狱。示例代码如下：

setTimeout(()=>{
    console.log('延迟一秒后输出')
    setTimeout(()=>{
        console.log('再延时两秒后输出')
        setTimeout(()=>{
            console.log('再延时三秒后输出')
        },3000)
    },2000)
},1000)

回调地狱所造成的问题：

• 代码耦合性太强，牵一发而动全身，难以维护

• 大量冗余代码相互嵌套，代码的可读性变差
  
  

如何解决回调地狱的问题

为了解决回调地狱的问题，ES6（ECMAScript 2015）中新增了Promise的概念。

Promise 的基本概念

① Promise 是一个构造函数

• 我们可以创建Promise的实例const p = new Promise()
• new 出来的 Promise 实例对象，代表一个异步操作

② Promise.prototype 上包含一个.then()方法

• 每一次 new Promise()构造函数得到的实例对象，都可以通过原型链的方式访问到.then()方法，例如 p.then()

③ .then()方法用来预先指定成功和失败的回调函数

• p.then(成功的回调函数，失败的回调函数)
• p.then(result=>{},error=>{})
• 调用.then()方法时，成功的回调函数是必选的、失败的回调函数是可选的
  
  

基于回调函数按顺序读取文件内容

// 读取文件 1.txt
fs.readFile('./files/1.txt','utf8',(err1,r1)=>{
    if(err1)return console.log(err1.message) // 读取文件 1 失败
    console.log(r1) // 读取文件 1 成功
    // 读取文件2.txt
    ...
	// 读取文件3.txt
	    ...
})

基于 then-fs 读取文件内容

由于 node.js官方提供的fs模块仅支持以回调函数方式读取文件，不支持Promise 的调用方式。因此需要先运行如下命令，安装 then-fs 这个第三方包，从而支持我们基于 Promise 的方式读取文件的内容：

npm install then-fs

then-fs的基本使用

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

/**
 * 基于 Promise 的方式读取文件
 */
import thenFs from 'then-fs'

// 注意：.then() 中的失败回调是可选的，可以被省略
thenFs.readFile('./files/1.txt','utf8').then(r1=>{ console.log(r1) }, err1 => { console.log(err1.messaage) })
thenFs.readFile('./files/2.txt','utf8').then(r2=>{ console.log(r2) }, err2 => { console.log(err2.messaage) })
thenFs.readFile('./files/3.txt','utf8').then(r3=>{ console.log(r3) }, err3 => { console.log(err3.messaage) })

上述代码无法保证文件的读取顺序，需要做进一步的改进。

.then()方法的特性

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

基于Promise 按顺序读取文件的内容

Promise 支持链式调用，从而来解决回调地狱的问题，示例代码如下：

thenFs.readFile('.files/1.txt', 'utf8') // 返回值是 Promise 的实例对象
    .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)
    })

通过.catch捕获错误

在Promise的链式操作中如果发生了错误，可以使用Promise.prototype.catch方法进行捕获和处理:

thenFs.readFile('.files/1.txt', 'utf8') // 返回值是 Promise 的实例对象
    .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)
    })
    .catch(err=>{
        console.log(err.message)
    })

如果不希望前面的错误导致后续的.then 无法正常执行，则可以将.catch的调用提前。

Promise.all() 方法

Promise.all()方法会发起并行的Promise异步操作，等所有的的异步操作全部结束后，才会执行下一步的.then操作（等待机制）。示例代码如下：

// 定义一个数组，存放 3 个读文件的异步操作
const promiseArr = [
    thenFs.readFile('./files/11.txt','utf8'),
    thenFs.readFile('./files/2.txt','utf8'),
    thenFs.readFile('./files/3.txt','utf8')
]

// 将 Promise 的数组，作为 Promise.all() 的参数
Promise.all(promiseArr)
    .then(([r1,r2,r3])=>{ // 所有文件读取成功（等待机制）
        console.log(r1,r2,r3)
    })
    .catch(err => { // 捕获 Promise 异步操作中的错误
        console.log(err.message)
    })

数组中的Promise实例的顺序，就是最终结果的顺序！

Promise.race() 方法

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

// 定义一个数组，存放 3 个读文件的异步操作
const promiseArr = [
    thenFs.readFile('./files/1.txt','utf8'),
    thenFs.readFile('./files/2.txt','utf8'),
    thenFs.readFile('./files/3.txt','utf8')
]

// 将 Promise 的数组，作为 Promise.race() 的参数
Promise.race(promiseArr)
    .then(result=>{ // 只要任何一个异步操作完成，就立即执行成功的回调函数（赛跑机制）
        console.log(r1,r2,r3)
    })
    .catch(err => { // 捕获 Promise 异步操作中的错误
        console.log(err.message)
    })

async/await

什么是 async/await

async/await是ES8(ECMASript 2017)引入的新语法，用来简化Promise异步操作。在async/await出现之前，开发者只能通过链式.then()的方式处理Promise异步操作。

.then链式调用的优点：解决了回调地狱的问题

.then链式调用的缺点：代码冗余、阅读性差、不易理解

async/await的使用注意事项

• ① 如果在function中使用了await，则function必须被async修饰

• ② 在 async 方法中，第一个 await 之前的代码会同步执行，await之后的代码会异步执行
  
  

EventLoop

JavaScript是单线程的语言

JavaScript是一门单线程执行的语言。也就是说，同一时间只能作同一件事情。
待执行的任务队列：

graph LR task1(任务一)-->task2(任务二)-->task3(任务三)-.->taskn(任务n)

单线程执行任务队列的问题：
如果前一个任务非常耗时，则后续的任务就不得不一直等待，从而导致程序假死的问题。

同步任务和异步任务

为了防止某个耗时任务导致程序假死的问题，JavaScript把待执行的任务分为了两类：
① 同步任务（synchronous）

• 又叫做<非耗时任务，指的是在主线程上排队执行的哪些任务
• 只有前一个任务执行完毕，才能执行后一个任务

② 异步任务（asynchronous）

• 又叫做耗时任务，异步任务由JavaScript委托给宿主环境进行执行
• 当异步任务执行完成后，会通知JavaScript主线程执行异步任务的回调函数
  
  

同步任务和异步任务的执行过程

• ① 同步任务由JavaScript主线程次序执行
• ② 异步任务委托给宿主环境执行
• ③ 已完成的异步任务对应的回调函数，会被加入到任务队列中等待执行
• ④ JavaScript主线程的执行栈被清空后，会读取任务队列中的回调函数，次序执行
• ⑤ JavaScript主线程不断重复上面第4步

JavaScript主线程从“任务队列”中读取异步任务的回调函数，放到执行栈中依次执行。这个过程是循环不断的，所以整个的这种运行机制又称为EventLoop（事件循环）

宏任务和微任务

什么是宏任务和微任务

JavaScript把异步任务又做了进一步的划分，异步任务又分为两类，分别是：
① 宏任务（macrotask）

• 异步 Ajax 请求、

• setTimeout、setInterval、

• 文件操作

• 其他宏任务

② 微任务（microtask）

• Promise.then、.catch和.finally

• process.nextTick

• 其他微任务

宏任务和微任务的执行顺序

graph LR

标签：ES6,console,log,异步,模块化,任务,Promise
来源： https://www.cnblogs.com/maplerain/p/16339856.html