Node模块，CommonJS规范详解

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多语言都采用这种组织代码的方式。在node环境中，一个.js文件就称之为一个模块（module），有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。node 应用由模块组成，采用 commonjs 模块规范。1、使用模块有什么好处？最大的好处是大大提高了代码的可维护性。其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们在编写程序的时候，也经常引用其他模块，包括node内置的模块和来自第三方的模块。使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。

// example.js
var x = 5;
var addx = function (value) { 
 return value + x;
};

上面代码中，变量x和函数addx，是当前文件example.js私有的，其他文件不可见。如果想在多个文件分享变量，必须定义为global对象的属性。

global.warning = true;

2、模块的基本使用commonjs规范规定，每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。'use strict';var s = 'hello';function greet(name) { console.log(s + ', ' + name + '!');}module.exports = greet;函数greet()是我们在hello模块中定义的，然后通过module.exports接口把函数greet作为模块的输出暴露出去，这样其他模块就可以使用greet函数了。require方法用于加载模块。我们再编写一个main.js文件，调用hello模块的greet函数：'use strict';// 引入hello模块:var greet = require('./hello');var s = 'michael';greet(s); // hello, michael!注意到引入hello模块用node提供的require函数：var greet = require('./hello');引入的模块作为变量保存在greet变量中，那greet变量到底是什么东西？其实变量greet就是在hello.js中我们用module.exports = greet;输出的greet函数。所以，main.js就成功地引用了hello.js模块中定义的greet()函数，接下来就可以直接使用它了。3、module对象node内部提供一个module构建函数。所有模块都是module的实例。

function module(id, parent) {  
    this.id = id; 
    this.exports = {};  
    this.parent = parent;  
     // ...

每个模块内部，都有一个module对象，代表当前模块。它有以下属性。

module.id模块的识别符，通常是带有绝对路径的模块文件名。

module.filename模块的文件名，带有绝对路径。

module.loaded返回一个布尔值，表示模块是否已经完成加载。

module.parent返回一个对象，表示调用该模块的模块。

module.children返回一个数组，表示该模块要用到的其他模块。

module.exports表示模块对外输出的值。例如：

// example.js
var jquery = require('jquery');
exports.$ = jquery;
console.log(module);

输出的module：

{ id: '.',
  exports: { '$': [function] },
  parent: null,
  filename: '/path/to/example.js',
  loaded: false,
  children:
   [ { id: '/path/to/node_modules/jquery/dist/jquery.js',
       exports: [function],
       parent: [circular],
       filename: '/path/to/node_modules/jquery/dist/jquery.js',
       loaded: true,
       children: [],
       paths: [object] } ],
  paths:
   [ '/home/user/deleted/node_modules',
     '/home/user/node_modules',
     '/home/node_modules',
     '/node_modules' ]
}

如果在命令行下调用某个模块，比如node something.js，那么module.parent就是null。如果是在脚本之中调用，比如require('./something.js')，那么module.parent就是调用它的模块。利用这一点，可以判断当前模块是否为入口脚本。

if (!module.parent) {
    // ran with `node something.js`
    app.listen(8088, function() {
        console.log('app listening on port 8088');
    })
} else {
    // used with `require('/.something.js')`
    module.exports = app;
}

module.exports属性module.exports属性表示当前模块对外输出的接口，其他文件加载该模块，实际上就是读取module.exports变量。exports变量为了方便，node为每个模块提供一个exports变量，指向module.exports。这等同在每个模块头部，有一行这样的命令。

var exports = module.exports;

所以，在对外输出模块接口时，也可以向exports对象添加方法。

exports.area = function (r) {
  return math.pi * r * r;
};

exports.circumference = function (r) {
  return 2 * math.pi * r;
};

注意，不能直接将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输出。如果你觉得，exports与module.exports之间的区别很难分清，一个简单的处理方法，就是放弃使用exports，只使用module.exports。4、require命令4.1 加载规则（详见node加载模块顺序）4.2 模块的缓存第一次加载某个模块时，node会缓存该模块。require命令第一次加载该脚本，就会执行整个脚本，然后在内存生成一个module对象，以后再加载该模块，就直接从缓存取出对应的module对象，然后获取module.exports属性。

{  //module对象
   id: '...',  
   exports: { ... }, 
   loaded: true,  ...
}

即使再次执行require命令，也不会再次执行该模块，而是到缓存之中取值。也就是说，commonjs 模块无论加载多少次，都只会在第一次加载时运行一次，以后再加载，就返回第一次运行的结果，除非手动清除缓存。所有缓存的模块保存在require.cache之中，如果想删除模块的缓存，可以像下面这样写。

// 删除指定模块的缓存
delete require.cache[modulename];

// 删除所有模块的缓存
object.keys(require.cache).foreach(function(key) {
  delete require.cache[key];
})

注意，缓存是根据绝对路径识别模块的，如果同样的模块名，但是保存在不同的路径，require命令还是会重新加载该模块。4.3 require.mainrequire方法有一个main属性，可以用来判断模块是直接执行，还是被调用执行。直接执行的时候（node module.js），require.main属性指向模块本身。

require.main === module  // true

调用执行的时候（通过require加载该脚本执行），上面的表达式返回false。5、模块的加载机制commonjs模块的加载机制是，输入的是被输出的值的拷贝。也就是说，一旦输出一个值，模块内部的变化就影响不到这个值。

// lib.js
var counter = 3;
function inccounter() {
  counter++;
}
module.exports = {
  counter: counter,
  inccounter: inccounter,
};

// main.js
var mod = require('./lib');

console.log(mod.counter);  // 3
mod.inccounter();
console.log(mod.counter); // 3

上面代码说明，lib.js模块加载以后，它的内部变化就影响不到输出的mod.counter了（调用mod.inccounter()方法时，操作的是lib.js模块中的变量counter，而不是导出的变量counter）。这是因为mod.counter是一个原始类型的值，会被缓存。除非写成一个函数，才能得到内部变动后的值。

// lib.js
var counter = 3;
function inccounter() {
  counter++;
}
module.exports = {
  get counter() {
    return counter
  },
  inccounter: inccounter,
};

上面代码中，输出的counter属性实际上是一个取值器函数。现在再执行main.js，就可以正确读取内部变量counter的变动了。

上面代码中，输出的counter属性实际上是一个取值器函数。现在再执行main.js，就可以正确读取内部变量counter的变动了。

5.1 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

采用module.compile()执行指定模块的脚本，逻辑如下。

module.prototype._compile = function(content, filename) {};

在该函数中需要执行以下几步：1. 生成一个require函数，指向module.require；2. 加载其他辅助方法到require；3. 一旦require函数准备完毕，整个所要加载的脚本内容，就被放到一个新的函数之中，这样可以避免污染全局环境。该函数的参数包括require、module、exports，以及其他一些参数。

(function (exports, require, module, __filename, __dirname) {
  // your code injected here!

// 执行读取的hello.js代码:
    function greet(name) {
        console.log('hello, ' + name + '!');
    }
    module.exports = greet;
    // hello.js代码执行结束

});

4. 执行该函数上面的第1步和第2步，require函数及其辅助方法主要如下。

require(): 加载外部模块

require.resolve()：将模块名解析到一个绝对路径

require.main：指向主模块

require.cache：指向所有缓存的模块

require.extensions：根据文件的后缀名，调用不同的执行函数module._compile方法是同步执行的，所以module._load要等它执行完成，才会向用户返回module.exports的值。5.2 模块的循环加载commonjs 模块的重要特性是加载时执行，即脚本代码在require的时候，就会全部执行。一旦出现某个模块被"循环加载"，就只输出已经执行的部分，还未执行的部分不会输出。我们来看一段代码：

// main.js
var a = require('./a.js');
var b = require('./b.js');
console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);

// a.js
exports.done = false;
var b = require('./b.js');
console.log('在 a.js 之中，b.done = %j', b.done);
exports.done = true;
console.log('a.js 执行完毕');

//b.js
exports.done = false;
var a = require('./a.js');
console.log('在 b.js 之中，a.done = %j', a.done);
exports.done = true;
console.log('b.js 执行完毕');

当第一次require（'a.js'）时，执行a.js脚本。先输出一个done变量，然后加载另一个脚本文件b.js。注意，此时a.js代码就停在这里，等待b.js执行完毕，再往下执行。b.js执行到第二行，就会去加载a.js，这时，就发生了“循环加载”。系统会去a.js模块对应对象的exports属性取值，可是因为a.js还没有执行完，从exports属性只能取回已经执行的部分，而不是最后的值。a.js已经执行的部分，只有一行。exports.done = false;因此，对于b.js来说，它从a.js只输入一个变量done，值为false。然后，b.js接着往下执行，等到全部执行完毕，再把执行权交还给a.js。于是，a.js接着往下执行，直到执行完毕。

最后输出的结果：

$ node main.js

在 b.js 之中，a.done = false
b.js 执行完毕
在 a.js 之中，b.done = true
a.js 执行完毕
在 main.js 之中, a.done=true, b.done=true

上面的代码证明了两件事。一是，在b.js之中，a.js没有执行完毕，只执行了第一行。二是，main.js执行到第二行时，不会再次执行b.js，而是输出缓存的b.js的执行结果，即它的第四行

exports.done = true;

5.3 node.js是如何实现模块node实现“模块”功能的奥妙在于javascript是一种函数式编程语言，它支持闭包。如果我们把一段javascript代码用一个函数包装起来，这段代码的所有“全局”变量就变成了函数内部的局部变量。请注意我们编写的hello.js代码是这样的：

var s = 'hello';
var name = 'world';
console.log(s + ' ' + name + '!');

node.js加载了hello.js后，它可以把代码包装一下，变成这样执行：

(function () {    
   // 读取的hello.js代码:    
   var s = 'hello';    
   var name = 'world';    
   console.log(s + ' ' + name + '!');    
   // hello.js代码结束
})();

这样一来，原来的全局变量s现在变成了匿名函数内部的局部变量。如果node.js继续加载其他模块，这些模块中定义的“全局”变量s也互不干扰。所以，node利用javascript的函数式编程的特性，轻而易举地实现了模块的隔离。