nodeJS学习（9）--- nodeJS模块：exports vs module.exports

模块简介：

通过Node.js的官方API可以看到Node.js本身提供了很多核心模块 http://nodejs.org/api/ 

• 这些核心模块被编译成二进制文件，可以 require('模块名') 去获取；
• 核心模块具有最高的加载优先级（有模块与核心模块同名时会体现）

（本次主要说自定义模块）

 

Node.js还有一类模块为文件模块，可以是 JavaScript 代码文件（.js作为文件后缀）、也可以是 JSON 格式文本文件（.json作为文件后缀）、还可以是编辑过的 C/C++ 文件（.node作为文件后缀）；

 

文件模块访问方式通过require('/文件名.后缀')   ； require('./文件名.后缀')   ； requrie('../文件名.后缀') 去访问，文件后缀可以省略；以"/"开头是以绝对路径去加载，以"./"开头和以"../"开头表示以相对路径加载，而以"./"开头表示同级目录下文件，

前面提到文件后缀可以省略，Nodejs 尝试加载的优先级 js文件 > json文件 > node文件

 

创建一个自定义模块

   以一个计数器为例

var outputVal  = 0;     //输出值
var increment = 1;    //增量

/* 设置输出值 */
function seOutputVal (val) {
    outputVal = val;
}

/* 设置增量 */
function setIncrement(incrementVal){
    increment = incrementVal;
}

/* 输出 */
function printNextCount()
{    
    outputVal += increment;
    console.log(outputVal) ;
}

function printOutputVal() {
    console.log(outputVal);
}
exports.seOutputVal = seOutputVal;
exports.setIncrement = setIncrement;

module.exports.printNextCount = printNextCount;

示例中重点在于exports和module.exports;提供了外部访问的接口，下面调用一下看看效果吧

调用自定义模块

     

/*
    一个Node.js文件就是一个模块，这个文件可能是Javascript代码、JSON或者编译过的C/C++扩展。
    重要的两个对象：
    require是从外部获取模块
    exports是把模块接口公开    
*/
var counter = require('./1_modules_custom_counter');

console.log('第一次调用模块[1_modules_custom_counter]');

counter.seOutputVal(10);               //设置从10开始计数
counter.setIncrement (10);             //设置增量为10

counter.printNextCount();
counter.printNextCount();
counter.printNextCount();
counter.printNextCount();

/*
    require多次调用同一模块不会重复加载
*/
var counter = require('./1_modules_custom_counter');

console.log('第二次调用模块[1_modules_custom_counter]');
counter.printNextCount();

 

运行可以发现通过 exports 和 module.exports 对外公开的方法都可以访问！

示例中可以看到，我两次通过require('./1_modules_custom_counter')获取模块，但是第二次引用后调用 printNextCount()方法确从60开始~~~

原因是node.js通过require，require多次调用同一模块不会重复加载，Node.js会根据文件名缓存所有加载过的文件模块，所以不会重新加载了

注意：通过文件名缓存是指实际文件名，并不会因为传入的路径形式不一样而认会是不同的文件

 

在我创建的1_modules_custom_counter文件中有一个printOutputVal()方法，它并没有通过exports或module.exports提供对外公开访问方法，

如果1_modules_load文件中直接访问运行会出现什么样的情况呢？

答案是：TypeError: Object #<Object> has no method 'printOutputVal'

 

require， exports， module.exports 区别：

• require 用来加载代码（模块），而 exports 和 module.exports 则用来导出代码。

  exports 是指向的 module.exports 的引用
  module.exports 初始值为一个空对象 {}，所以 exports 初始值也是 {}
  require() 返回的是 module.exports 而不是 exports

 

nodejs中exports与module.exports的区别:

 

API提供了解释 http://nodejs.org/api/modules.html 

Note that exports is a reference to module.exports making it suitable for augmentation only. If you are exporting a single item such as a constructor you will want to use module.exports directly instead
exports 仅仅是 module.exports 的一个地址引用。nodejs 只会导出 module.exports 的指向，如果 exports 指向变了，那就仅仅是 exports 不在指向 module.exports，于是不会再被导出

 

• Module.exports：如果你想你的模块是一个 特定的类型 就用 Module.exports。
• exports: 如果你想的模块是一个 典型的“实例化对象” 就用 exports。

原文：http://www.hacksparrow.com/node-js-exports-vs-module-exports.html

参考：http://www.cnblogs.com/kongxianghai/p/3936197.html

http://www.cnblogs.com/zhongweiv/p/nodejs_module.html

 

1. nodejs 模块中的 exports 对象：你可以用它创建你的模块。例如：

假设这是 rocker.js 文件:

# rocker.js 

exports.name = function() {
    console.log('My name is Lemmy Kilmister');
};

则，在另一文件中，你可以这样引用：

var rocker = require('./rocker.js');
rocker.name();    // 'My name is Lemmy Kilmister'

强调：

（1）给 exports 赋值其实是给 module.exports 这个空对象添加了属性，eg：

var name = 'nswbmw'; 
exports.name = name; 
exports.sayName = function() {  console.log(name); } 

# 给 exports 赋值其实是给 module.exports 这个空对象添加了两个属性而已，上面的代码相当于：
var name = 'nswbmw';
module.exports.name = name; 
module.exports.sayName = function() {  console.log(name); }

 

     （2）两者的使用方法不同，eg：

使用 exports：

# circle.js -- 使用 exports 定义一个方法
exports.area = function(r) {  return r * r * Math.PI; } 

# app.js -- 使用上面文件里定义的方法
var circle = require('./circle'); 
console.log(circle.area(4));    # 使用，引用的方式：***.area()

使用 Module.exports:

# area.js -- 使用 module.exports 定义方法
module.exports = function(r) {  return r * r * Math.PI;  

# app.js -- 使用上面文件定义的方法
var area = require('./area'); 
console.log(area(4));  # 直接使用，***()

 

2. Module.exports :

• Module.exports 才是真正的接口，exports只不过是它的一个辅助工具。
• 最终返回给调用的是Module.exports而不是exports。
• 所有的exports收集到的属性和方法，都赋值给了Module.exports。当然，这有个前提，就是Module.exports本身不具备任何属性和方法。如果，Module.exports已经具备一些属性和方法，那么exports收集来的信息将被忽略。eg:修改 rocker.js 如下：

  # 修改的 rocker.js
  module.exports = 'ROCK IT!';  # 将 module.exports = {}; 变为了 module.exports = '';
  exports.name = function() { 
      console.log('My name is Lemmy Kilmister'); 
  }; 
  

  此时，再次引用执行 rocker.js 如下：

  var rocker = require('./rocker.js');
  rocker.name(); // TypeError: Object ROCK IT! has no method 'name' 
  # 发现报错：对象“ROCK IT!”没有name方法 

  rocker 模块忽略了 exports 收集的 name 方法，返回了一个字符串“ROCK IT!”。由此可知，你的模块并不一定非得返回“实例化对象”。你的模块可以是任何合法的javascript对象--boolean, number, date, JSON, string, function, array等等。

• 你的模块可以是任何你设置给它的东西。如果你没有显式的给 Module.exports 设置任何属性和方法，那么你的模块就是 exports 设置给 Module.exports 的属性。

  eg1: 你的模块是一个类：

# 再次修改 rocker.js
module.exports = function(name, age) {
    this.name = name;
    this.age = age;
    this.about = function() {
        console.log(this.name +' is '+ this.age +' years old');
    };
};

可以这样使用它：

var Rocker = require('./rocker.js');
var r = new Rocker('Ozzy', 62);
r.about();   // Ozzy is 62 years old

 

eg2: 你的模块是一个数组：

# 再次修改 rocker.js

module.exports = ['Lemmy Kilmister', 'Ozzy Osbourne', 'Ronnie James Dio', 'Steven Tyler', 'Mick Jagger'];

可以这样使用它：

var rocker = require('./rocker.js');
console.log('Rockin in heaven: ' + rocker[2]); //Rockin in heaven: Ronnie James Dio

 

     现在你明白了，如果你想你的模块是一个特定的类型就用 Module.exports，直接 变量/new方法 使用。如果你想的模块是一个典型的“实例化对象”就用 exports，需引用使用 .***。

• 给Module.exports添加属性类似于给exports添加属性。例如：

  module.exports.name = function() {
      console.log('My name is Lemmy Kilmister');
  };

  同样， exports 是这样的：

  exports.name = function() {
      console.log('My name is Lemmy Kilmister');
  };

  强调：这两种定义效果并不相同（本人还是有点晕，后续将继续学习）。前面已经提到 module.exports 是真正的接口，exports 只不过是它的辅助工具。推荐使用 exports 导出，除非你打算从原来的 “实例化对象” 改变成一个 类型!!

 

exports和module.exports 覆盖

上面也也基本明白了exports和module.exports的关系和区别，但如果同时针对printNextCount()方法存在exports和module.exports，结果如何？

调用结果

从结果可以看出，并没有报错，表示可以这么定义，但最终 module.exports 覆盖了exports

 

****虽然结果不会报错，如果这么用开发中难免会有一些问题存在，所以****

1. 最好别分别定义 module.exports 和 exports

2. NodeJs 开发者建议导出对象用 module.exports, 导出多个方法和变量用 exports

其它...

 　　API中还提供了其它的方法，就不细讲了，在上面例子的基础上自已动手一输出就知道了

module.id：返回string类型的模块标识，一般为完全解析后的文件名

module.filename：返回一个string类型的完全解析后文件名

module.loaded：返回一个bool类型，表示是否加载完成

module.parent：返回引用该模块的模块

module.children：返回该模块引用的所有模块对象的数组