ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

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

2022-06-03 13:00:40  阅读：142  来源： 互联网

标签：ES6 console log 异步 模块化 任务 Promise


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主线程执行异步任务的回调函数

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

image

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

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

宏任务和微任务

什么是宏任务和微任务

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

  • 异步 Ajax 请求、

  • setTimeout、setInterval、

  • 文件操作

  • 其他宏任务

② 微任务（microtask）

  • Promise.then、.catch和.finally

  • process.nextTick

  • 其他微任务

image

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

graph LR

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有