将程序代码划分为多个文件时，module.exports用于向模块的使用者发布变量和函数。源文件中的require（）调用将替换为从模块加载的相应module.exports。

编写模块时记住

模块加载被缓存，只有初始调用评估JavaScript。可以在模块中使用局部变量和函数，而不需要导出所有内容。module.exports对象也可用作导出速记。但当返回一个单独的函数时，请始终使用module.exports。

根据：“模块第2部分-编写模块”。

将程序代码划分为多个文件时，module.exports用于向模块的使用者发布变量和函数。源文件中的require（）调用将替换为从模块加载的相应module.exports。

编写模块时记住

模块加载被缓存，只有初始调用评估JavaScript。可以在模块中使用局部变量和函数，而不需要导出所有内容。module.exports对象也可用作导出速记。但当返回一个单独的函数时，请始终使用module.exports。

根据：“模块第2部分-编写模块”。

如果将对新对象的引用分配给exports和/或modules.exports，则必须注意以下几点：

1.以前附加到原始导出或模块的所有财产/方法都会丢失。导出当然会丢失，因为导出的对象现在将引用另一个新的对象

这一点很明显，但如果在现有模块的开头添加导出方法，请确保本机导出对象在末尾没有引用另一个对象

exports.method1 = function () {}; // exposed to the original exported object
exports.method2 = function () {}; // exposed to the original exported object

module.exports.method3 = function () {}; // exposed with method1 & method2

var otherAPI = {
    // some properties and/or methods
}

exports = otherAPI; // replace the original API (works also with module.exports)

2.如果exports或module.exports中的一个引用新值，则它们不再引用同一对象

exports = function AConstructor() {}; // override the original exported object
exports.method2 = function () {}; // exposed to the new exported object

// method added to the original exports object which not exposed any more
module.exports.method3 = function () {}; 

3.狡猾的后果。如果同时更改了对exports和module.exports的引用，很难说哪个API是公开的（看起来module.export获胜）

// override the original exported object
module.exports = function AConstructor() {};

// try to override the original exported object
// but module.exports will be exposed instead
exports = function AnotherConstructor() {}; 

module.exports是作为require调用的结果实际返回的对象。

exports变量最初被设置为同一个对象（即，它是一个简写“别名”），因此在模块代码中，您通常会编写如下内容：

let myFunc1 = function() { ... };
let myFunc2 = function() { ... };
exports.myFunc1 = myFunc1;
exports.myFunc2 = myFunc2;

导出（或“公开”）内部作用域函数myFunc1和myFunc2。

在调用代码中，您将使用：

const m = require('./mymodule');
m.myFunc1();

其中最后一行显示require的结果（通常）只是一个可以访问其财产的普通对象。

注意：如果您覆盖导出，则它将不再引用module.exports。因此，如果您希望为导出分配新对象（或函数引用），则还应将该新对象分配给module.export

值得注意的是，添加到导出对象的名称不必与要添加的值的模块内部作用域名称相同，因此可以：

let myVeryLongInternalName = function() { ... };
exports.shortName = myVeryLongInternalName;
// add other objects, functions, as required

然后：

const m = require('./mymodule');
m.shortName(); // invokes module.myVeryLongInternalName

目的是：

模块化编程是一种强调将程序的功能分离成独立的，可互换的模块，每个模块都包含所有必要的内容以仅执行期望功能的一个方面。

维基百科

我想，如果没有模块化/可重用代码，编写大型程序会变得困难。在nodejs中，我们可以使用module.exports创建模块化程序，该模块定义了我们公开的内容，并使用require编写程序。

请尝试以下示例：

文件日志.js

function log(string) { require('fs').appendFileSync('log.txt',string); }

module.exports = log;

标准输出日志.js

function log(string) { console.log(string); }

module.exports = log;

程序.js

const log = require('./stdoutLog.js')

log('hello world!');

处决

$node程序.js你好，世界！

现在尝试交换/的stdoutLog.js/fileLog.js。

参考链接如下：

exports = module.exports = function(){
    //....
}

导出或模块的财产。导出，例如函数或变量，将在外部公开

有一点你必须更加注意：不要覆盖导出。

为什么？

因为导出只是module.exports的引用，所以可以将财产添加到导出中，但如果覆盖导出，引用链接将断开。

很好的例子：

exports.name = 'william';

exports.getName = function(){
   console.log(this.name);
}

坏例子：

exports = 'william';

exports = function(){
     //...
}

如果您只想公开一个函数或变量，如下所示：

// test.js
var name = 'william';

module.exports = function(){
    console.log(name);
}   

// index.js
var test = require('./test');
test();

这个模块只公开了一个函数，name的属性对外是私有的。