ES6ES6模块化回顾nodejs中如何实现模块化 node.js遵循了CommonJS的模块化规范。其中：导入其他

ES6模块化

回顾nodejs中如何实现模块化

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

导入其他模块使用require()方法
导出使用module.exports对象

npm

npm root -g 用来查看全局安装的包的位置

前端模块化规范的分类

在ES6模块化规范诞生之前，javaScript社区已经尝试并提出了AMD、CMD、CommonJS等模块化规范但是，这些由社区提出的模块化标准，But there still have something different. so 并不是浏览器与服务器通用的模块化标准，例如：

AMD和CMD适用于浏览器端的JavaScript模块化
CommonJS适用于服务器端的javaScript模块化太多的模块化规范给开发者增加了学习难度与开发成本。因此，大一统的ES6模块化规范诞生了！that is amazing

CommonJS 导入导出

模块暴露方式有两种

module.exports = value
exports.name = value

使用时有几点注意

module.exports 可以暴露任意数据

不能使用exports=value的形式暴露数据, 模块内部module与exports的隐式关系exports=module.exports={}

//导出时不能使用 exportss = value 的形式暴露数据
//exports和module.exports的隐式关系
exports = module.exports = {}

require 导入 npm 包的基本流程

在当前文件夹下node_modules中寻找同名的文件夹
在上级目录中下的node_modules中寻找同名的文件夹，直至找到磁盘根目录

What is 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模块化的基本语法主要包含如下3种用法

默认导出与默认导入

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

let n1 = 10
let n2 = 20
function show() {}
export default {
  n1, 
  show,
}

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

// 此处引入时一定要加 .js 后缀。要不然 it will be error. and you cannot find it.
import m1 from './01.默认导出.js'
console.log(m1)
// { n1: 10, show: [Function: show] }

默认导出注意事项

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

按需导出与按需导入

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

export let s1 = 'aaa'
export let s2 = 'bbb'
export function say() {}
export default {
  a: 20,
}

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

import info, { s1, s2, say } from './03.按需导出.js'
console.log(s1)
console.log(s2)
console.log(say)
console.log(info)

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

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

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

import './05.直接运行模块中的代码.js'

Promise

Promise的基本概念

Promise 是一个构造函数

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

Promise.prototype上包含一个 .then方法

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

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

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

Promise.all() 等待所有异步任务执行完毕

import thenFs from 'then-fs'
let arr = [
  thenFs.readFile('./file/1.txt', 'utf8'),
  thenFs.readFile('./file/2.txt', 'utf8'),
  thenFs.readFile('./file/3.txt', 'utf8'),
]
Promise.all(arr).then((res) => {
  //等待所有执行完毕
  console.log(res) // [ '1111', '2222', '3333' ]
})

Promise.race() 等待最快的异步任务执行完毕

import thenFs from 'then-fs'
let arr = [
  thenFs.readFile('./file/1.txt', 'utf8'),
  thenFs.readFile('./file/2.txt', 'utf8'),
  thenFs.readFile('./file/3.txt', 'utf8'),
]
Promise.race(arr).then((res) => {
  //赛跑机制，只要最快的一个执行完毕。立即执行.then() 之后的操作
  console.log(res)
})

async/await

async/await的使用注意事项

如果在function中使用了await, 则function必须使用async修饰
在async方法中，第一个await之前的代码会同步执行，await之后的代码会异步执行

import thenFs from 'then-fs'

console.log('A')
async function getAllFile() {
  console.log('B')
  const r1 = await thenFs.readFile('./file/1.txt', 'utf8')
  const r2 = await thenFs.readFile('./file/2.txt', 'utf8')
  const r3 = await thenFs.readFile('./file/3.txt', 'utf8')
  console.log(r1, r2, r3)
  console.log('D')
}
getAllFile()
console.log('C')

// 输出
// A
// B
// C
// 1111 2222 3333
// D

EventLoop

1. javaScript是单线程语言

JavaScript是一门单线程编程语言。也就是说，同一时间只能做一件事。

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

2. 同步任务和异步任务

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

同步任务(synchronous)

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

异步任务(asynhronous)

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

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

同步任务由JavaScript主线程按次序执行
异步任务则委托给宿主环境执行(浏览器，nodejs)
已完成的异步任务对应的回调函数，会被加入到任务队列中等待执行
JavaScript主线程的执行栈被清空后，会读取任务队列中的回调函数，按次序执行
JavaScript主线程不断重复第4步

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

面试题:

import thenFs from 'then-fs'
console.log('A')
thenFs.readFile('./file/1.txt', 'utf8').then((res) => {
  console.log('B')
})
setTimeout(() => {
  console.log('C')
}, 0)
console.log('D')
// 输出
// A
// D
// C
// B

宏任务和微任务

什么是宏任务和微任务

JavaScript 把异步任务又做了进一步划分，异步任务又分为两类，分别是：

1. 宏任务(macrotask)

异步Ajax请求
setTimeout、setInterval
文件操作
其他宏任务

2. 微任务(microtask)

Promise.then、.catch、.finally
process.nextTick
其他微任务

宏任务和微任务的执行顺序：每一个宏任务执行完之后，都会检查是否存在待执行的微任务，如果有，则执行完所有微任务之后，再继续执行下一个宏任务

面试题：

setTimeout(function () {
  // 宏任务
  console.log('1')
})
//new Promise 是属于同步任务
let promise = new Promise((resolve) => {
  console.log('2')
  resolve()
})
// .then属于微任务
promise.then(() => {
  console.log('3')
})
console.log('4')

//输出
//2
//4
//3
//1

console.log('1')
setTimeout(() => {
  console.log('2')
  new Promise((resolve) => {
    console.log('3')
    resolve()
  }).then(() => {
    console.log('4')
  })
})
new Promise((resolve) => {
  console.log('5')
  resolve()
}).then(() => {
  console.log('6')
})
setTimeout(() => {
  console.log('7')
  new Promise((resolve) => {
    console.log('8')
    resolve()
  }).then(() => {
    console.log('9')
  })
})

// 输出
//1
//5
//6
//2
//3
//4
//7
//8
//9

ES6