返回

Node.js(笔记06) - 模块化

发布时间:2022-12-30 23:20:42 337
# javascript# java# java# 信息

什么是模块化

遵守固定的规则,把一个大文件拆成独立并互相依赖的多个小模块。

代码模块化的优势:

1)提高代码的复用性;

2)提高代码的可维护性;

3)可以实现按需加载;

模块块规范是:对代码模块化拆分和组合时,遵守的规则;

1)引用模块;

2)暴露接口;


Node.js 模块分类

1)内置模块:由Node.js官方提供的,如: fs、path 和 http 模块;

2)自定义模块:用户自己创建的 js 文件;

3)第三方模块:第三方开发的,使用前需下载;


加载模块

使用 require() 方法,加载需要的内置模块、自定义模块和第三方模块;

 引入模块,代码示例:

// 加载内置模块
const fs = require('fs')
// 加载自定义模块,相当于加载文件
const custom = require('./custom.js')
// 加载第三方模块
const moment = require('moment')

注意1:使用 require() 方法加载其他模块时,会执行被加载模块中的代码;

注意2:使用 require() 方法加载自定义模块时,扩展名 .js 可以省略;

写个文件 test.js ,并保存到 "./files/" 目录下: 

console.log('这是 text.js 内的代码!')

在 demo.js 文件引入:

const test = require('./files/text.js')
// const test = require('./files/text')
console.log(test)

提示:引入模块的时候可以省略 js ;

终端输出:

Node.js(笔记06) - 模块化_模块化

可以执行,还多了一个空对象 {} ,后面再说;


模块作用域

和函数作用域类似,在自定义模块中定义的变量、方式等成员,只能在当前模块内被访问,这种模块级别的访问限制,叫做模块作用域;

也就是说,在test.js 中定义的常量, 在被引用时不能输出;

模块作用域的好处:防止了全局变量污染的问题


共享模块作用域中的成员


module 对象

在每个自定义模块中,都会包含 module 对象,里面存储了和当前模块有关的信息。

新建个 js 文件,输出 module 看下:

console.log(module)

Node.js(笔记06) - 模块化_模块化_02

module.exports 对象

在自定义模块中,使用 module.exports 对象,将模块内的成员共享出去,供外界使用;外界用 require() 方法引入自定义模块时,得到的就是 module.exports 所指向的对象。

提示:在自定义模块中,默认情况下  module.exports={} ,这就解释了,之前为什么会输出空对象了;

使用 module.exports 对象就可以共享属性和方法:新建 m1.js

module.exports.username = 'jacky'
module.exports.sayhello = function(){
console.log('Hello Module');
}

在 demo.js 中引入 m1.js 自定义模块:

const m1 = require('./m1')
console.log(m1);

终端输出:

Node.js(笔记06) - 模块化_Node.js_03

修改 m1.js 并共享一个常量:

module.exports.username = 'jacky'
module.exports.sayhello = function(){
console.log('Hello Module');
}
const age = 20
module.exports.age = age

再看下终端输出:

Node.js(笔记06) - 模块化_Node.js_04


共享成员时注意点

使用 require() 方法导入模块时,导入的结果,永远以 module.exports 指向的对象为准

示例说明:

module.exports.username = 'jacky'
module.exports.sayhello = function(){
console.log('Hello Module');
}

// 让 module.exports 指向了一个新对象
module.exports = {
nickname : 'Tom',
sayhi : function(){
console.log('hi!')
}
}

提示:这里让 module.exports 直接指向了新的对象;

再执行一下 demo.js:

Node.js(笔记06) - 模块化_Node.js_05

提示:输出为新的对象;

提示:指向新对象后,再给新对象追加属性和方法呢?就又都有了;

示例说明:

// 让 module.exports 指向了一个新对象
module.exports = {
nickname : 'Tom',
sayhi : function(){
console.log('hi!')
}
}

module.exports.username = 'jacky'
module.exports.sayhello = function(){
console.log('Hello Module');
}

提示:仅仅是把代码换回到下面,意思是在新对象后又追加了属性和方法:

看下终端输出:

Node.js(笔记06) - 模块化_模块化_06


exports 对象

由于 module.exports 单词写起来比较复杂,为了简化向外共享代码,Node提供了 exports 对象。默认情况下, exports 和 module.exports 指向同一个对象。最后共享的结果,还是以 module.exports 指向的对象为准。 

示例说明:

console.log(exports);
console.log(module.exports);
console.log(exports === module.exports);

看下终端的比较结果:

Node.js(笔记06) - 模块化_模块化_07

说明这两个对象指向的是同一个对象;

所以之前的代码可以简定:

module.exports.username = 'jacky'
module.exports.sayhello = function(){
console.log('Hello Module');
}
const age = 20
module.exports.age = age

等效于:

exports.username = 'jacky'
exports.sayhello = function(){
console.log('Hello Module')
}
const age = 20
exports.age = age


共享成员使用误区

require() 引入模块时,得到的永远是 module.exports 指向的对象


误区一

exports.username = 'jacky'

// 让 module.exports 指向了一个新对象
module.exports = {
nickname : 'Tommi',
sayhi : function(){
console.log('hi!')
}
}

module.exports 指向了新的对象,并以 module.exports 指向的对象为准;

Node.js(笔记06) - 模块化_Node.js_08

即使使用  exports 追加也不行,只能使用  module.exports 追加才可以;

module.exports ={
nickname : 'Tommi',
sayhi(){
console.log(hi);
}
}
exports.othername = 'jacky' // 追加不上
module.exports.username = 'jerry'

Node.js(笔记06) - 模块化_Node.js_09

Node.js(笔记06) - 模块化_模块化_10

提示:随着 module.exports 另外指向了对象,原来的 exports 无效了;


误区二

module.exports.username = 'zs'
exports ={
gender : '男',
age:20
}

这次是用 exports 来指向新对象了,结果又如何呢?

Node.js(笔记06) - 模块化_Node.js_11

示意图:

Node.js(笔记06) - 模块化_Node.js_12

所以,再次验证了 module.exports 所指向的对象优先级高;


误区三

exports.username = 'zs'
module.exports.gender = '男'

这次得到的 module.exports 对象有几个属性呢?

Node.js(笔记06) - 模块化_模块化_13

是两个,因为对象没有变,指向是同一个对象;

Node.js(笔记06) - 模块化_Node.js_14


误区四

exports = {
username : 'zs',
gender:'男'
}
module.exports = exports // exports 赋值给了 module.exports
module.exports.age = 22

提示:exports 和  module.exports 都指向了新的对象,所以引入的模块有三个属性;

Node.js(笔记06) - 模块化_模块化_15

示意图:

Node.js(笔记06) - 模块化_模块化_16

注意:为了防止混乱,不要在同一个模块中同时使用 exports 和 module.exports ,即使混用了,也要知道引入的模块的对象,最终都是 module.export 指向的对象。


CommonJS 规范

Node.js 遵循了 CommonJS 模块化规范,CommonJS 规定了 模块的特性 和 各模块之间如何相互依赖。

CommonJS 规定:

1)每个模块内部, module 变量代表当前模块;

2)module 变量是一个对象,它的 exports 属性(即 module.exports)是对外的接口;

3)加载某个模块,其实是加载该模块的 module.exports 属性。require() 方法用于加载模块;


特别声明:以上内容(图片及文字)均为互联网收集或者用户上传发布,本站仅提供信息存储服务!如有侵权或有涉及法律问题请联系我们。
举报
评论区(0)
按点赞数排序
用户头像
精选文章
thumb 中国研究员首次曝光美国国安局顶级后门—“方程式组织”
thumb 俄乌线上战争,网络攻击弥漫着数字硝烟
thumb 从网络安全角度了解俄罗斯入侵乌克兰的相关事件时间线
下一篇
移除数组中的元素 2022-12-30 22:51:29