我发现这个链接对回答上述问题很有用。

http://timnew.me/blog/2012/04/20/exports-vs-module-exports-in-node-js/

添加到其他帖子节点中的模块系统

var exports = module.exports 

在执行代码之前。因此，当您想要exports=foo时，您可能需要执行module.exports=exports=foo，但使用exports.foo=foo应该可以

我通过了一些测试，我认为这可能会对这个问题有所启发。。。

应用.js：

var ...
  , routes = require('./routes')
  ...;
...
console.log('@routes', routes);
...

/routes/index.js的版本：

exports = function fn(){}; // outputs "@routes {}"

exports.fn = function fn(){};  // outputs "@routes { fn: [Function: fn] }"

module.exports = function fn(){};  // outputs "@routes function fn(){}"

module.exports.fn = function fn(){};  // outputs "@routes { fn: [Function: fn] }"

我甚至添加了新文件：

./routes/index.js：

module.exports = require('./not-index.js');
module.exports = require('./user.js');

./routes/not-index.js：

exports = function fn(){};

./routes/user.js：

exports = function user(){};

我们得到输出“@routes｛｝”

---

./routes/index.js：

module.exports.fn = require('./not-index.js');
module.exports.user = require('./user.js');

./routes/not-index.js：

exports = function fn(){};

./routes/user.js：

exports = function user(){};

我们得到输出“@routes｛fn:｛｝，user:｛}｝”

---

./routes/index.js：

module.exports.fn = require('./not-index.js');
module.exports.user = require('./user.js');

./routes/not-index.js：

exports.fn = function fn(){};

./routes/user.js：

exports.user = function user(){};

我们得到输出“@routes｛user:[Function:user]｝”如果我们将user.js更改为｛ThisLoadedLast:[Function:ThisLoadedLast]｝，我们将得到输出“@routes｛ThisLoadedLast:[Function:TThisLoadedlast]｝”。

---

但如果我们修改/routes/index.js。。。

./routes/index.js：

module.exports.fn = require('./not-index.js');
module.exports.ThisLoadedLast = require('./user.js');

./routes/not-index.js：

exports.fn = function fn(){};

./routes/user.js：

exports.ThisLoadedLast = function ThisLoadedLast(){};

…我们得到“@routes｛fn:｛fn:[Function:fn]｝，ThisLoadedLast:｛ThisLoadedLast:[Function:ThisLoadedLast]｝｝”

所以我建议在模块定义中始终使用module.exports。

我不完全理解Node内部的情况，但如果您能理解这一点，请发表评论，因为我相信这会有所帮助。

--快乐的编码

最初，module.exports=导出，require函数返回module.exports引用的对象。

如果我们向对象添加属性，比如exports.a=1，那么module.exports和exports仍然引用同一个对象。因此，如果我们调用require并将模块分配给变量，那么该变量具有属性a，其值为1；

但是如果我们重写其中一个，例如exports=function（）｛｝，那么它们现在就不同了：exports引用新对象，module.exports引用原始对象。如果我们需要该文件，它将不会返回新对象，因为module.exports不引用新对象。

对我来说，我将继续添加新属性，或者将它们都覆盖到新对象中。只是忽略一个是不正确的。请记住，module.exports才是真正的老板。

JavaScript通过引用的副本传递对象

这与JavaScript中通过引用传递对象的方式有细微差别。

exports和module.exports都指向同一个对象。exports是变量，module.exports是模块对象的属性。

假设我写了这样的东西：

exports = {a:1};
module.exports = {b:12};

exports和module.exports现在指向不同的对象。修改导出不再修改module.exports。

当import函数检查module.exports时，它得到｛b:12｝

module.exports和exports都指向同一个函数database_module（cfg）｛…｝。1|变量a，b；2|a=b=function（）｛console.log（“旧”）；｝；3|b=函数（）｛console.log（“New”）；｝；4|5|a（）；//“旧”6|b（）；//“新建”您可以将第3行的b更改为a，输出是相反的。结论是：a和b是独立的。因此module.exports=exports=nano=function database_module（cfg）｛…｝相当于：var f=函数database_module（cfg）｛…｝；模块导出=f；出口=f；假设上面是foo.js所需要的module.js。module.exports=exports=nano=function database_module（cfg）｛…｝的好处现在很清楚了：在foo.js中，由于module.exports是必需的（'./module.js'）：var output=require（'./modules.js'）（）；在moduls.js中：可以使用exports代替module.exports。

因此，如果exports和module.exports都指向同一个对象，您会很高兴。

让我们用两种方式创建一个模块：

单向

var aa = {
    a: () => {return 'a'},
    b: () => {return 'b'}
}

module.exports = aa;

第二种方式

exports.a = () => {return 'a';}
exports.b = () => {return 'b';}

这就是require（）集成模块的方式。

第一种方式：

function require(){
    module.exports = {};
    var exports = module.exports;

    var aa = {
        a: () => {return 'a'},
        b: () => {return 'b'}
    }
    module.exports = aa;

    return module.exports;
}

第二种方式

function require(){
    module.exports = {};
    var exports = module.exports;

    exports.a = () => {return 'a';}
    exports.b = () => {return 'b';}

    return module.exports;
}