Node.js之ES6模块化及Promise对象

ES6模块化

CommonJS 规范

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

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

模块化开发好处

模块化开发的好处有很多，其中：

• 实现了在JS文件中引用其他文件
• 避免命名冲突的问题
• 大家都遵守同样的模块化规范写代码，降低了沟通的成本，极大方便了各个模块之间的相互调用
• 只需关心当前模块本身的功能开发，需要其他模块的支持时，在模块内调用目标模块即可

模块化规范划分

在 ES6 模块化规范诞生之前，JavaScript 社区已经尝试并提出了 AMD 、 CMD 、 CommonJS 等模块化规范。 但是，这些由社区提出的模块化标准，还是存在一定的差异性与局限性、并不是浏览器与服务器通用的模块化标准

• AMD 和 CMD 适用于浏览器端的 Javascript 模块化
• CommonJS 适用于服务器端的 Javascript

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

ES6模块化开发注意点

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

• 确保安装了 v13.0.0 或更高版本的 node.js
• 在 package.json 的根节点中添加 “type”: “module” 节点
• 配置之后，则只能使用ES6模块化语法，不能再使用CommonJS语法了

1.5 ES6 导入导出

主模块

// //导入子模块
// //方法1.默认导入不能解构接收
// import obj from './02-子模块.js'
// console.log(obj);
// //不能再接收位置直接解构
//import { fn, num } from './02-子模块.js'

//方法2.按需导入
// import { str, fn2 } from './02-子模块.js'
// console.log(str);
// fn2
//import bbb from './02-子模块.js'

//方法3.只导入 不接收 使用的是功能
import './02-子模块.js'

//es6也有缓存机制 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

子模块

//导出内容
//方法1.默认导出一次不允许导出多次
// const num = 123
// function fn() {
// console.log('我是函数fn');
// }
// export default { fn, num }

//方法2.按需导出可以导出多次
//必须定义的时候就导出
// export const str = 'abc'
// export function fn2() {
// console.log('我是函数fn2');
// }

//方法3.不导出任何数据让别人使用自己的功能
for (let i = 0; i < 3; i++) {console.log('重要的事情说三遍!');
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Promise对象

异步操作是 JavaScript 编程的麻烦事，麻烦到一直有人提出各种各样的方案，试图解决这个问题。早期使用回调函数处理异步编码，但存在回调地狱的问题。ES6中，新增了Promise 对象，从此异步编程摆脱了回调函数的束缚。

使用语法

let p = new Promise((resolve, reject) => {
    // ... some code
    if (/* 异步操作成功 */) {
        resolve(value);
    } else {
        reject(error);
    }
}); 
1
2
3
4
5
6
7
8

注意点:

• new Promise()
• 必须传入一个函数作为Promise的参数，这个函数在 new Promise的时候就会执行
• 函数有 resolve 和 reject 两个形参
• 函数就相当于一个容器，可以将异步任务放到这里
• 将异步任务成功的结果传给 resolve 函数；将失败的信息传给 reject 函数

p.then(
    result => { /* 获取成功的结果 */ }
);
// 或者
p.then(
    result => { /* 获取成功的结果 */ },
    err => { /* 获取失败的结果 */ }
);
// 或者
p.then(
    result => { /* 获取成功的结果 */ }
).catch(err => { /* 获取失败的结果 */ }
); 
1
2
3
4
5
6
7
8
9
10
11
12
13

注意点:

• then方法接收以个函数类型的参数，只处理成功
• then方法接收两个函数类型的参数，分别用于接收 resolve 的值 和 reject 的值
• then方法也可以只接收一个参数，表示只接收 resolve 的值，失败的结果可以通过链式调用catch方法捕获

Promise中的同步异步

new Promise 和 new 其他对象一样，是同步任务。

获取结果时（调用 resolve 触发 then方法时）是异步的。

使用Promise解决回调地狱

代码略；

Promise 封装

// 封装
function myReadFile(filename) {
    return new Promise((resolve, reject) => {
        fs.readFile(filename, 'utf-8', (err, data) => {
            err ? reject(err) : resolve(data.length);
        })
    });
}
// 调用
myReadFile('./files/a.txt')
    .then(a => {
        console.log(a);
        return myReadFile('./files/b.txt');
    })
    .then(b => {
        console.log(b);
        return myReadFile('./files/c.txt');
    })
    .then(c => {
        console.log(c)
    }) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

第三方then-fs解决回调地狱

// npmithen-fs
const fs = require('then-fs');
fs.readFile('./files/a.txt', 'utf-8')
    .then(res1 => {
        console.log(res1);
        return fs.readFile('./files/b.txt', 'utf-8')
    })
    .then(res2 => {
        console.log(res2);
        return fs.readFile('./files/b.txt', 'utf-8')
    })
    .then(res3 => {
        console.log(res3)
    }) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：未来很多模块支持Promise对象开发，就是返回的是一个Promise对象； 如 axios

最后是原图