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

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

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

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

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

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

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

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

基本上，答案在于当通过require语句需要模块时会发生什么。假设这是第一次需要模块。

例如：

var x = require('file1.js');

file1.js的内容：

module.exports = '123';

执行上述语句时，将创建Module对象。其构造函数函数为：

function Module(id, parent) {
    this.id = id;
    this.exports = {};
    this.parent = parent;
    if (parent && parent.children) {
        parent.children.push(this);
    }

    this.filename = null;
    this.loaded = false;
    this.children = [];
}

正如您所看到的，每个模块对象都有一个带有名称导出的属性。这是最终作为需求的一部分返回的内容。

require的下一步是将file1.js的内容包装成一个匿名函数，如下所示：

(function (exports, require, module, __filename, __dirname) { 
    //contents from file1.js
    module.exports = '123;
});

这个匿名函数的调用方式如下，这里的模块引用前面创建的模块对象。

(function (exports, require, module, __filename, __dirname) { 
    //contents from file1.js
    module.exports = '123;
}) (module.exports,require, module, "path_to_file1.js","directory of the file1.js");

正如我们在函数内部看到的那样，exports的形式参数指的是module.exports。本质上，这是为模块程序员提供的便利。

然而，这种便利需要谨慎使用。在任何情况下，如果尝试将新对象分配给导出，请确保这样做。

exports = module.exports = {};

如果我们按照错误的方式执行，module.exports将仍然指向作为模块实例一部分创建的对象。

exports = {};

因此，向上面的导出对象添加任何内容都不会对module.exports对象产生任何影响，也不会作为require的一部分导出或返回任何内容。

我只是做了一些测试，结果发现，在nodejs的模块代码中，应该是这样的：

var module.exports = {};
var exports = module.exports;

so:

1:

exports = function(){}; // this will not work! as it make the exports to some other pointer
module.exports = function(){}; // it works! cause finally nodejs make the module.exports to export.

2:

exports.abc = function(){}; // works!
exports.efg = function(){}; // works!

3:但是，在这种情况下

module.exports = function(){}; // from now on we have to using module.exports to attach more stuff to exports.
module.exports.a = 'value a'; // works
exports.b = 'value b'; // the b will nerver be seen cause of the first line of code we have do it before (or later)

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都指向同一个对象，您会很高兴。

module.export和exports都指向同一个对象，然后对模块求值。

使用require语句在另一个模块中使用模块时，添加到module.exports对象的任何属性都将可用。导出是一种快捷方式，可用于相同的事情。例如：

module.exports.add = (a, b) => a+b

相当于写：

exports.add = (a, b) => a+b

因此，只要不为导出变量分配新值，就可以了。当你这样做时：

exports = (a, b) => a+b 

当您为导出分配新值时，它不再引用导出的对象，因此将保持模块的本地状态。

如果您计划为module.exports分配一个新值，而不是向可用的初始对象添加新的财产，您可能应该考虑如下所示：

module.exports = exports = (a, b) => a+b

Node.js网站对此有很好的解释。