提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
Node应用是由模块组成的,Node遵循了CommonJS的模块规范,来隔离每个模块的作用域,使每个模块在它自身的命名空间中执行。
CommonJS 是一套代码规范, 目的是为了构建 JavaScript 在浏览器之外的生态系统 (服务器端, 桌面端). JavaScript 诞生之初只是为了写网页小脚本, 并不作为开发大型复杂应用的语言, 其自身有很多不足. 并且, 官方规范 (ECMAScript) 制定的时间较早, 涵盖范围较小, 对于后端开发而言, 例如文件系统, I/O 流, 模块系统, 等等方面都没有相应的标准. 基于种种的不足, CommonJS 规范致力于弥补 JavaScript 没有标准的缺陷, 让 JavaScript 有能力去开发复杂应用, 同时具备跨平台能力。
模块必须通过 module.exports 导出对外的变量或接口,通过 require() 来导入其他模块的输出到当前模块作用域中。
(1)所有代码运行在当前模块作用域中,不会污染全局作用域;
(2)模块同步加载,根据代码中出现的顺序依次加载;
(3)模块可以多次加载,但是只会在第一次加载时运行一次,然后运行结果就被缓存了,以后再加载,就直接读取缓存结果。要想让模块再次运行,必须清除缓存。
模块:就是一个独立的功能体。
在NodeJS下,模块分为:自定义模块、核心模块、第三方模块。
在NodeJS下,每一个文件都是一个模块。
如果我们现在建立一个主文件(main.js),以及主文件需要引用的文件(second.js),即建立了两个模块。
NodeJS自动为每个文件添加了构造函数,所有的代码被构造函数包含:
(function(exports,require,module,__filename,__dirname){ 程序员自己写的代码 })
require命令的基本功能是,读入并执行一个JavaScript文件,然后返回该模块的exports对象。如果没有发现指定模块,会报错。同一级目录写路径./,后缀名.js可以省略。
我们在second.js里写入如下代码:
console.log('haha') var a = 1; function fn(){ console.log(2); }
然后在main.js里首先使用require引入secons.js,然后打印出它的结果,再打印一下它里面的创建的变量。
结果如上图:打印second.js里定义的变量时会报错,此时就需要用到另一个模块module。
根据参数的不同格式,require命令去不同路径寻找模块文件。
1
如果参数字符串以“/”开头,则表示加载的是一个位于绝对路径的模块文件。比如,require(’/home/marco/foo.js’)将加载/home/marco/foo.js。
2
如果参数字符串以“./”开头,则表示加载的是一个位于相对路径(跟当前执行脚本的位置相比)的模块文件。比如,require(’./circle’)将加载当前脚本同一目录的circle.js。
3
如果参数字符串不以“./“或”/“开头,则表示加载的是一个默认提供的核心模块(位于Node的系统安装目录中,如http,fs),或者一个位于各级node_modules目录的已安装模块(全局安装或局部安装)。例如,脚本/home/user/projects/foo.js执行了require(‘bar.js’)命令,Node会依次搜索以下文件。
/user/local/lib/node/bar.js
/home/user/projects/node_modules/bar.js
/home/user/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
这样设计的目的是,使得不同的模块可以将所依赖的模块本地化。
4
如果参数字符串不以“./“或”/“开头,而且是一个路径,比如require(‘example-module/path/to/file’),则将先找到example-module的位置,然后再以它为参数,找到后续路径。
5
如果指定的模块文件没有发现,Node会尝试为文件名添加.js、.json、.node后,再去搜索。.js件会以文本格式的JavaScript脚本文件解析,.json文件会以JSON格式的文本文件解析,.node文件会以编译后的二进制文件解析。
6
如果想得到require命令加载的确切文件名,使用require.resolve()方法。
通常,我们会把相关的文件会放在一个目录里面,便于组织。这时,最好为该目录设置一个入口文件,让require方法可以通过这个入口文件,加载整个目录。在目录中放置一个package.json文件,并且将入口文件写入main字段。例如:
// package.json { "name" : "some-library", "main" : "./lib/some-library.js" }
require发现参数字符串指向一个目录以后,会自动查看该目录的package.json文件,然后加载main字段指定的入口文件。如果package.json文件没有main字段,或者根本就没有package.json文件,则会加载该目录下的index.js文件或index.node文件。
指代当前所在的模块对象。Node内部提供一个Module构建函数。所有模块都是Module的实例。
每个模块内部,都有一个module对象,代表当前模块。它有以下属性:
module.id:
模块的识别符,通常是带有绝对路径的模块文件名。 module.filename:
模块的文件名,带有绝对路径。
module.loaded:
返回一个布尔值,表示模块是否已经完成加载。
module.parent:
返回一个对象,表示调用该模块的模块。
module.children:
返回一个数组,表示该模块要用到的其他模块。
module.exports:
当前模块的导出对象,公开的属性和方法。表示当前模块对外输出的接口,其他文件加载该模块,实际上就是读取module.exports变量。
module.paths:
从当前文件目录开始查找node_modules目录;然后依次进入父目录,查找父目录下的node_modules目录;依次迭代,直到根目录下的node_modules目录。
如:
console.log(module.id); console.log(module.filename);
下面这些模块都是我们自己写的,就是自定义模块。
我们在second.js里写入如下代码:
console.log('haha') var a = 1; function fn(){ console.log(2); } //使用module公开变量或者函数 //module.exports意思是要导出的对象 module.exports.vname = 'bear6'; module.exports.mya = a; module.exports.fn = fn;
此时module导出了vname,mya,fn这些变量,main.js接收后就可以使用它们了。
当然,导出时不但可以使用module.exports,也可以使用exports。
exports:指代module.exports
这等同在每个模块头部,有一行这样的命令。
var exports = module.exports;
举例如下:
second.js
console.log('haha') var a = 1; function fn(){ console.log(2); } //使用module公开变量或者函数 //module.exports意思是要导出的对象 exports.vname = 'bear6'; exports.mya = a; exports.fn = fn;
此时,module.exports和exports里的地址指向的是同一导出对象。
我们可以直接导出匿名函数
second.js
module.exports.fn = function (){ console.log('haha'); }
main.js
当然,也可以直接导出对象,不过要注意,当导出对象时,exports与module.exports就不再指向同一个对象了。
second.js
module.exports = { ename : 'tom', say : function (){} } console.log(exports === module.exports)
main.js
由结果可以看出console.log(exports === module.exports)的打印结果为false。
注意:不能直接将exports变量指向一个值,因为这样等于切断了exports与module.exports的联系。
exports = function(x) {console.log(x)};
上面这样的写法是无效的,因为exports不再指向module.exports了。
下面的写法也是无效的。
exports.hello = function() { return 'hello'; }; module.exports = 'Hello world';
上面代码中,hello函数是无法对外输出的,因为module.exports被重新赋值了。
这意味着,如果一个模块的对外接口,就是一个单一的值,不能使用exports输出,只能使用module.exports输出。
我们在haha.js里写入一个类,然后把它导出去,用heihei.js来接受它,并创建类的实例然后引用类的方法。
haha.js
class Person{ constructor(name,age) { this.name = name; this.age = age; } say = function (){ console.log("姓名为:",this.name); } hi(){ console.log("年龄为:",this.age); } } module.exports = Person;
heihei.js
let Person = require('./haha'); let p1 = new Person('刘备',12); let p2 = new Person('诸葛亮',33); p1.say(); p2.hi();
结果如下:
创建两个模块main.js(主模块),circle(功能模块),在功能模块下创建两个函数,传递半径,计算圆的周长和面积,并导出两个函数,在主模块下引入功能模块,并调用两个函数。
main.js
//引入circle.js模块 var circle = require('./circle.js'); console.log('圆的面积为:',circle.getArea(4).toFixed(2)); console.log('圆的周长为:',circle.getLength(4).toFixed(2));
circle.js
//计算面积 function getArea(r){ return Math.PI * Math.pow(r,2); } //计算周长 function getLength(r){ return 2 * Math.PI * r; } //导出两个函数 module.exports.getArea = getArea; module.exports.getLength = getLength;
代表当前模块的绝对目录和模块名称
代表当前模块的绝对目录
第一次加载某个模块时,Node会缓存该模块。以后再加载该模块,就直接从缓存取出该模块的module.exports属性。
如果想要多次执行某个模块,可以让该模块输出一个函数,然后每次require这个模块的时候,重新执行一下输出的函数。所有缓存的模块保存在require.cache之中,如果想删除模块的缓存,可以像下面这样写。
// 删除指定模块的缓存 delete require.cache[moduleName]; // 删除所有模块的缓存 Object.keys(require.cache).forEach(function(key) { delete require.cache[key]; })
注意,缓存是根据绝对路径识别模块的,如果同样的模块名,但是保存在不同的路径,require命令还是会重新加载该模块。
当引入以路径开头的目录模块时,它首先会找到此目录文件下的package.json文件,package.json文件里大多为对象,要求是,属性名必须用双引号括起来,如果属性值为字符串,也需要括起来,然后会寻找package.json中的main属性对应的文件名称,如果找不到就会引入此目录下的index.js。
练习:创建模块01.js,引入当前目录下的02目录模块,在02目录模块下有一个文件fun.js,导出一个函数sort(给一个数组顺序排序),在01.js中调用该函数。
目录格式如下:
fun.js:
//创建一个函数sort,功能是将一个数组顺序排序 function sort(arr){ for(let i = 1;i < arr.length;i++){ for(let j = i;j > 0;j--){ if(arr[j-1] > arr[j]) { let temp = arr[j - 1]; arr[j - 1] = arr[j]; arr[j] = temp; } } } return arr; } //导出函数sort module.exports.sort = sort;
package.json:
{ "name": "02", "version": "1.0.0", "dependencies": { }, "main" : "fun.js" }
我们使main属性的值为fun.js,这样当01.js引入02目录时,首先会引入02目录下的fun.js模块。
01.js:
//引入以路径开头的目录 let s = require('./02'); console.log(s.sort([4,55,3,11,29,0]));
结果如图:
引入不以路径开头的目录模块时,会自动到当前目录下的node_modules中寻找此目录,如果找不到node_modules,会往上一级查找直到顶级目录(如c盘),常用于引入第三方模块。
练习:创建目录03,在03下创建03_1.js引入不以路径开头的目录模块03_2,里面有文件foo.js,含有可以对数组进行逆序排序的fun函数,导出fun函数,并在03_1.js中调用函数。
目录格式如下:
foo.js:
//创建一个函数fun,功能为逆序排序 function fun(arr){ for(let i = 0;i < arr.length;i++){ for(let j = 0;j < arr.length-i-1;j++){ if(arr[j+1] > arr[j]){ let temp = arr[j+1]; arr[j+1] = arr[j]; arr[j] = temp; } } } return arr; } //导出fun函数 module.exports.fun = fun;
package.json:
{ "name": "03_2", "version": "1.0.0", "dependencies": { }, "main" : "foo.js" }
03_1.js:
//引入不以路径开头的03_2目录 var s = require('03_2'); console.log(s.fun([1,32,5,76,0,88]));
结果如下:
如果发生模块的循环加载,即A加载B,B又加载A,则B将加载A的不完整版本。
// a.js exports.x = 'a1'; console.log('a.js ', require('./b.js').x); exports.x = 'a2';
// b.js exports.x = 'b1'; console.log('b.js ', require('./a.js').x); exports.x = 'b2';
// main.js console.log('main.js ', require('./a.js').x); console.log('main.js ', require('./b.js').x);
上面代码是三个JavaScript文件。其中,a.js加载了b.js,而b.js又加载a.js。这时,Node返回a.js的不完整版本,所以执行结果如下。
修改main.js,再次加载a.js和b.js:
console.log('a.js中的x值为:',require('./a').x); console.log('b.js中的x值为:',require('./b').x); console.log('----end-----'); console.log('a.js中的x值为:',require('./a').x); console.log('b.js中的x值为:',require('./b').x);
执行上面代码,结果如下:
上面代码中,第二次加载a.js和b.js时,会直接从缓存读取exports属性,所以a.js和b.js内部的console.log语句都不会执行了。
require命令是CommonJS规范之中,用来加载其他模块的命令。它其实不是一个全局命令,而是指向当前模块的module.require命令,而后者又调用Node的内部命令Module._load。
Module._load = function(request, parent, isMain) { // 1. 检查 Module._cache,是否缓存之中有指定模块 // 2. 如果缓存之中没有,就创建一个新的Module实例 // 3. 将它保存到缓存 // 4. 使用 module.load() 加载指定的模块文件, // 读取文件内容之后,使用 module.compile() 执行文件代码 // 5. 如果加载/解析过程报错,就从缓存删除该模块 // 6. 返回该模块的 module.exports};
上面的第4步,采用module.compile()执行指定模块的脚本,逻辑如下:
Module.prototype._compile = function(content, filename) { // 1. 生成一个require函数,指向module.require // 2. 加载其他辅助方法到require // 3. 将文件内容放到一个函数之中,该函数可调用 require // 4. 执行该函数};
上面的第1步和第2步,require函数及其辅助方法主要如下:
require(): 加载外部模块
require.resolve():将模块名解析到一个绝对路径
require.main:指向主模块
require.cache:指向所有缓存的模块
require.extensions:根据文件的后缀名,调用不同的执行函数
一旦require函数准备完毕,整个所要加载的脚本内容,就被放到一个新的函数之中,这样可以避免污染全局环境。该函数的参数包括require、module、exports,以及其他一些参数。
Module._compile方法是同步执行的,所以Module._load要等它执行完成,才会向用户返回module.exports的值。