Nodejs专栏 - Nodejs的模块化(module.exports和exports原理, Nodejs模块化原理)

Nodejs的模块化

在我们日常进行web开发的过程中, 对于模块化总是跑不掉的, 各家的模块化有各家的实现方式, 百花齐放, nodejs遵循commonjs规范的模块化

1. 把每一个文件都看做是一个模块

2. 如果一个模块需要暴露一些数据或者功能供其他模块使用, 需要写上module.exports = xxx, 该过程称之为模块的导出

3. 如果一个模块需要用到另一个模块导出的代码, 需要使用require(’…’)来引入, require函数的返回值就是索引模块暴露出的内容

4. 模块中的所有全局代码产生的变量, 函数均不会造成全局污染, 仅在模块内使用

5. 模块具有缓存, 第一次导入模块时就会缓存该模块, 之后再次导入同一个模块的时候, 直接使用之前的结果

6. 每个模块可能被其他模块所依赖, 也可能会依赖于其他模块

module.exports和require的使用

我新建一个index.js

// index.js
const result = require('./test.js');
console.log(result); // 输出{ a: 100 }

然后我再新建一个test.js

// test.js
const a = 100;
module.exports = {
    a
}

我们进入terminal, 执行index.js文件, 会发现打印出来的result是一个对象, 因为我们在test.js中直接导出了一个对象, 对象中有个变量a

而如果我什么都不导出就光秃秃的写个a的声明加赋值, 我在index.js中是拿不到任何东西的

// test.js
const a = 100; 

// index.js
const result = require('./test.js');
console.log(result); // 输出{}

如图我们会看到输出的是空, 所以我们但凡想将变量或者数据供外部使用, 我们就要使用module.exports对想让外界模块可使用的变量或者数据进行导出, 再到另一个模块中使用require进行导入两者缺一不可

在test文件中, 我们想要导出啥, 我们就module.exports啥, 比如我就想导出个a

// test.js
const a = 100;
module.exports = a;

// index.js
const result = require('./test.js');
console.log(result); // 输出的就是100

而本质上module.exports就是一个对象, 我们可以通过module.exports导出多个变量或者数据

// test.js
const a = 100;
const b = 'helloWorld';
const c = {
    name: 'loki',
    age: 18
}
const foo = () => {
    console.log(c);
}  

console.log(module.exports); // 输出{}

// 可以写成这样
/**
 * module.exports.a = a;
 * module.exports.b = b;
 * module.exports.c = c;
 * module.exports.foo = foo;
 * 但是这样还是比较累
 * **/

//我们一般写成这样

module.exports = {
    a,
    b,
    c,
    foo
}

// index.js
const result = require('./test.js');
console.log(result);

所以module.exports我们可以随意玩

关于exports

有朋友可能会觉得我没有写exports, 没错我在刻意的避开exports, 接下来我来写一些关于module.exports和exports还有一些node的执行环境的概念, 你可能以后就会少用exports了

首先我们来铺垫铺垫原生js, 怕你们忘了

let fstObj = {};
let secObj = fstObj;
console.log('fstObj恒等于secObj吗?', fstObj === secObj); // true

fstObj.a = 100;
secObj.b = 200;
console.log('第一次输出fstObj的值', fstObj); //{a: 100, b: 200}

fstObj = {
    c: 300
}

secObj.d = 400;
console.log('第二次输出fstObj的值',fstObj);

module.exports = {
    a,
    b,
    c,
    foo
}

上方node index.js后输出结果如下

输出结果为什么第一次的时候b加进来了, 第二次的d却不知所踪, 这个原因如果你基础比较好的话会想的很明白

• 一开始fstObj 取得了一个引用值的地址, 于是fstObj指向那个引用值

• 我们将fstObj的值赋给secObj, 由于fstObj手里拿的是指针, 所以fstObj会把自己的指针给予secObj, 这个时候fstObj和secObj指向同一个地址, 所以当我修改secObj的值, fstObj也被改了

• 后来我们将fstObj的值直接换了一个新的地址,这个时候secObj跟fstObj已经不指向同一个地址了, 所以给secObj加上d的属性fstObj再也无法感知了

这会我们来说说exports和module.exports

先看看实例吧

// test.js
console.log('module.exports的值', module.exports);
console.log('exports的值', exports);
console.log('module.exports恒等于exports吗？', module.exports === exports);
module.exports.a = 10;
exports.b = 20;

// index.js
const result = require('./test.js');
console.log('从test.js导入的结果', result);

执行结果如下

这个还不够, 还得再看一个

// test.js
console.log('module.exports的值', module.exports);
console.log('exports的值', exports);
console.log('module.exports恒等于exports吗？', module.exports === exports);
module.exports = {
    userName: 'loki'
};
console.log('现在module.exports恒等于exports吗？', module.exports === exports);
exports.age = 18;

// index.js
const result = require('./test.js');
console.log('从test.js导入的结果', result);

输出结果如下

在上方的这两个例子中我们可以总结几点

• module.exports和exports在出生的时候是相等的, 而且都是空对象{}, 代表着他们在一开始指向同一个地址

module.exports = exports = {};

• 当我们require一个模块的时候, 被导入模块中的代码会被通篇执行一次, 所以我们在requiretest.js的时候会将test文件中的打印语句都输出一次

• 当我们将module.exports的指针更改以后, exports将不再生效, 证明系统默认导出给我们的是module.exports的值

其实在底层中, commonjs的规范会把每个导出的文件封装在一个函数中, 而后会往这个函数中传递几个参数, 其中有两个就是我们熟悉的exports和module.exports了, 而函数执行完毕以后一定会返回module.exports出去

function(exports,require, module, __filename,__dirname) {
//我们写的代码
// module.exports...
// const xxx = xxx;
return module.exports
}

想要证明这个其实很简单, 既然我们写的模块化代码会被放在函数体中, 而且函数体也会给我们传入这些参数, 那么我们直接在test文件的第一行输出arguments不就好了

// test.js
console.log(arguments);
console.log('exports恒等于arguments[0]吗？', exports === arguments[0]);
console.log('require恒等于arguments[1]吗？', require === arguments[1]);
console.log('module.exports恒等于arguments[2]吗？', module === arguments[2]);
console.log('__filename恒等于arguments[3]吗？', __filename === arguments[3]);
console.log('__dirname恒等于arguments[4]吗？', __dirname === arguments[4]);

// index.js
const result = require('./test.js');
console.log('从test.js导入的结果', result);

输出结果如下

而由于只要我们更改module.exports的指针exports就会失效, 根据我们之前的js铺垫, 所以他的函数体中应该是这么写的

function(exports, require, module, __filename, __dirname) {
    module.exports = {};
    exports = module.exports;
    // ... 我们写的代码
    return module.exports;
}

所以这就是笔者为什么推荐大家尽量使用module.exports而非exports的原因, 系统始终都在返回module.exports, 而如果我们用exports的话, 哪天不小心更改了module.exports的值, 那么代码就出问题了

总结

• nodejs的模块化遵守commonjs规范
• 其实我们之所以能够使用exports和module.exports还有webpack中的__dirname等, 是因为nodejs的模块化本质上把每个模块化文件都放入一个函数中执行, 而我们能够使用的这些变量都是函数传递给我们的参数
• 能用module.exports就绝不使用exports

至此, 遵守commonjs规范的Nodejs的模块化原理就写完了, 我希望我讲清楚了

来源：CSDN

作者：付金权

链接：https://blog.csdn.net/weixin_44238796/article/details/104438716