最近查了下这块区别，然后作为笔记把别人的文章整理了一下，参考文章附在最后了。

用法区别：

如果要对外暴露属性或方法，就用 exports 就行，要暴露对象(类似class，包含了很多属性和方法)，就用 module.exports。

exports

exports对于本身来讲是一个变量（对象），它不是module的引用，它是{}的引用，它指向module.exports的{}模块

exports只能使用语法来向外暴露内部变量或者方法：如exports.xxx = xxx;

// functions.js
var func1 = function() {
   console.log("func1");
};
 
var func2 = function() {
   console.log("func2");
};
 
exports.function1 = func1;
exports.function2 = func2;

调用functions.js

var functions = require("./functions");
functions.function1();
functions.function2();

module.exports

module是一个变量，指向一块内存，exports是module中的一个属性，存储在内存中，然后exports属性指向{}模块

module.exports既可以通过语法，也可以直接赋值一个对象。

• module.exports = some
• module.exports.some = some

返回一个对象

// 模块
var app = {
    name: 'app',
    version: '1.0.0',
    sayName: function(name){
        console.log(this.name);
    }
}
module.exports = app;

调用方式

var app = require('./app.js');
app.sayName('hello');//hello

返回一个构造函数

// class.js
var CLASS = function(args){
     this.args = args;
}
module.exports = CLASS;

调用class.js

var CLASS = require('./class.js');
varc = new CLASS('arguments');

在使用上，以下两种方式的导出效果是一致的。

var sayHello = function() {
  console.log('hello');
}

exports.sayHello = sayHello
 module.exports.sayHello = sayHello;

均可以使用如下方式进行调用

var exports_module = require('./exports-module');
exports_module.sayHello()

但是假如使用了如下方式

var sayHello = function() {
  console.log('hello');
}

module.exports = sayHello;

则调用时require的是sayHell本身，这点需要注意。

调用：

var exports_module = require('./exports-module');
exports_module() // hello

exports、module.exports

require: node 和 es6 都支持的引入
export / import : 只有es6 支持的导出引入
module.exports / exports: 只有 node 支持的导出

node模块

Node里面的模块系统遵循的是CommonJS规范。
那问题又来了，什么是CommonJS规范呢？

CommonJS定义的模块分为: 模块标识(module)、模块定义(exports) 、模块引用(require)

先解释 exports 和 module.exports
在一个node执行一个文件时，会给这个文件内生成一个 exports和module对象，
而module又有一个exports属性。他们之间的关系如下图，都指向一块{}内存区域。

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

//输出结果为：true
exports = [0, 1];
console.log(exports === module.exports);

//输出结果为：false

exports.png

看如下例子

// module-exports.js
let a = 100;
 
console.log(module.exports); //能打印出结果为：{}
console.log(exports); //能打印出结果为：{}
 
exports.a = 200; //这里辛苦劳作帮 module.exports 的内容给改成 {a : 200}
 
exports = '指向其他内存区'; //这里把exports的指向指走
console.log(exports); //能打印出结果为：指向其他内存区
console.log(module.exports); //能打印出结果为：{ a: 200 }

调用

var a = require('./exports-module');
console.log(a) // 打印为 {a : 200}

从上面可以看出，其实require导出的内容是module.exports的指向的内存块内容，并不是exports的。
简而言之，区分他们之间的区别就是 exports 只是 module.exports的引用，辅助后者添加内容用的。

真实的过程分析可以如下所示，相当于我们的模块里存在exports和module两个变量，而exports只是一个快捷方式。无论操作了exports还是module.exports，最终都是修改了共同引用内存的内存内容，而最终导出的是module.exports这个实体，所以当exports和module.exports都有指向的时候，最终导出的就是module.exports指向的新内存，exports指向的内存就被抛弃了。所以不管怎么样，使用module.exports一般导出没毛病。

再看个例子

// 相当于js本身声明一个内存空间{}，我们强为之命名为obj，exports和module.exports都引用了obj。
var obj = {};
exports = obj;
module.exports = obj;

// 私有方法
function foo() {}
// 比如
exports.bar = 'bar'
// 结果就是
obj => {bar: 'bar'}

module.exports.a = 'a';

// 此时bar 属性和a属性都挂在到了obj上，导出结果是
obj => {bar: 'bar', a: 'a'};

// 但是加入直接给module.exports赋值，就会改变导出的结果为新的对象foo了
module.exports = foo;

// => 此时导出结果为 foo方法 

// 最终require的时候是引入的module.exports

ES中的模块导出导入 export和export default

export 和 export default
首先我们讲这两个导出，下面我们讲讲它们的区别

1. export与export default均可用于导出常量、函数、文件、模块等
2. 在一个文件或模块中，export、import可以有多个，export default仅有一个
3. 通过export方式导出，在导入时要加{ }，export default则不需要
4. export能直接导出变量表达式，export default不行。

export和export default可以同时使用。

export-test.js

//导出变量
export const a = '100';  
 
 //导出方法
export const dogSay = function(){ 
    console.log('wang wang');
}
 
 //导出方法第二种
function catSay(){
   console.log('miao miao'); 
}
export { catSay };
 
//export default导出
const m = 100;
export default m; 
//export defult const m = 100;// 这里不能写这种格式。

index.js

//index.js
var express = require('express');
var router = express.Router();
 
import { dogSay, catSay } from './testEs6Export'; //引入了 export 方法 
import m from './testEs6Export';  //引入了 export default 
 
import * as testModule from './testEs6Export';//as 集合成对象导出所有export
 
 
/* GET home page. */
router.get('/', function(req, res, next) {
  dogSay();
  catSay();
  console.log(m);
  testModule.dogSay();
  console.log(testModule.m); // undefined ,因为as导出包含所有 export， 聚集在一起作为一个对象，不包含而export default 。
  console.log(testModule.default); // 100
  res.send('恭喜你，成功验证');
});
 
module.exports = router;

总结

1.module.exports才是真正的接口，exports只不过是它的一个辅助工具，　最终返回给调用的是module.exports而不是exports。module.exports 初始值为一个空对象 {},而exports为指向module.exports 的引用

2. 在require() 的时候，返回的是 module.exports 而不是 exports，因此，直接赋值exports常常会出现错误，而赋值为module.exports常常是解决这一问题的折中办法

3.所有的exports收集到的属性和方法，都赋值给了Module.exports。当然，这有个前提，就是module.exports本身不具备任何属性和方法。

如果，module.exports已经具备一些属性和方法，那么exports收集来的信息将被忽略。

ES6模块规范

不同于CommonJS，ES6使用 export 和 import 来导出、导入模块。

export跟export default 有什么区别呢？

1、export与export default均可用于导出常量、函数、文件、模块等

2、你可以在其它文件或模块中通过import+(常量 | 函数 | 文件 | 模块)名的方式，将其导入，以便能够对其进行使用

3、在一个文件或模块中，export可以有多个，export default仅有一个

4、通过export方式导出，在导入时要加{ }，export default则不需要

参考文章：

终于讲清楚了nodejs中exports和module.exports的区别

exports和module.exports的区别

nodejs模块中exports和module.exports的区别