本文主要是介绍Node.js学习九（模块化），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 一、CommonJS规范
• • 1、什么是CommonJS规范
  • 2、CommonJS规范的主要内容
  • 3、CommonJS模块的特点
• 二、模块
• • 1、require导入模块
  • • （1）require()
    • （2）参数的加载规则
    • （3）目录的加载规则
  • 2、module导出模块
  • 3、expotrs
  • 4、练习
  • • （1）导出一个类
    • （2）调用函数
  • 5、__filename
  • 6、__dirname
  • 7、模块的缓存
• 三、引入目录模块具体讲解
• • 1、引入以路径开头的目录模块
  • 2、引入不以路径开头的目录模块
• 四、模块的循环加载
• 五、require的内部处理流程

      Node应用是由模块组成的，Node遵循了CommonJS的模块规范，来隔离每个模块的作用域，使每个模块在它自身的命名空间中执行。

一、CommonJS规范

1、什么是CommonJS规范

      CommonJS 是一套代码规范, 目的是为了构建 JavaScript 在浏览器之外的生态系统 (服务器端, 桌面端). JavaScript 诞生之初只是为了写网页小脚本, 并不作为开发大型复杂应用的语言, 其自身有很多不足. 并且, 官方规范 (ECMAScript) 制定的时间较早, 涵盖范围较小, 对于后端开发而言, 例如文件系统, I/O 流, 模块系统, 等等方面都没有相应的标准. 基于种种的不足, CommonJS 规范致力于弥补 JavaScript 没有标准的缺陷, 让 JavaScript 有能力去开发复杂应用, 同时具备跨平台能力。

2、CommonJS规范的主要内容

      模块必须通过 module.exports 导出对外的变量或接口，通过 require() 来导入其他模块的输出到当前模块作用域中。

3、CommonJS模块的特点

（1）所有代码运行在当前模块作用域中，不会污染全局作用域；
（2）模块同步加载，根据代码中出现的顺序依次加载；
（3）模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。

二、模块

      模块：就是一个独立的功能体。
      在NodeJS下，模块分为：自定义模块、核心模块、第三方模块。
      在NodeJS下，每一个文件都是一个模块。
      如果我们现在建立一个主文件（main.js），以及主文件需要引用的文件（second.js），即建立了两个模块。
      NodeJS自动为每个文件添加了构造函数，所有的代码被构造函数包含：

(function(exports,require,module,__filename,__dirname){
	程序员自己写的代码
})

1、require导入模块

（1）require()

      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。

（2）参数的加载规则

      根据参数的不同格式，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()方法。

（3）目录的加载规则

      通常，我们会把相关的文件会放在一个目录里面，便于组织。这时，最好为该目录设置一个入口文件，让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文件。

2、module导出模块

      指代当前所在的模块对象。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接收后就可以使用它们了。

3、expotrs

      当然，导出时不但可以使用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输出。

4、练习

（1）导出一个类

      我们在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();

结果如下：

（2）调用函数

      创建两个模块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;

5、__filename

      代表当前模块的绝对目录和模块名称

6、__dirname

      代表当前模块的绝对目录

7、模块的缓存

      第一次加载某个模块时，Node会缓存该模块。以后再加载该模块，就直接从缓存取出该模块的module.exports属性。
      如果想要多次执行某个模块，可以让该模块输出一个函数，然后每次require这个模块的时候，重新执行一下输出的函数。所有缓存的模块保存在require.cache之中，如果想删除模块的缓存，可以像下面这样写。

// 删除指定模块的缓存
delete require.cache[moduleName];
// 删除所有模块的缓存
Object.keys(require.cache).forEach(function(key) {
  	delete require.cache[key];
})

注意，缓存是根据绝对路径识别模块的，如果同样的模块名，但是保存在不同的路径，require命令还是会重新加载该模块。

三、引入目录模块具体讲解

1、引入以路径开头的目录模块

      当引入以路径开头的目录模块时，它首先会找到此目录文件下的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]));

结果如图：

2、引入不以路径开头的目录模块

      引入不以路径开头的目录模块时，会自动到当前目录下的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的内部处理流程

      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的值。

这篇关于Node.js学习九（模块化）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！