模块系统是nodejs的基础，使用频率也很高。在使用nodejs过程中，以下几个关于模块系统的问题是否常常困扰着你：
- 为什么在模块中有全局的require、module.exports、exports、__dirname、__filename等关键字,它们是从哪来的？
- 为什么一定要使用module.exports或者exports导出模块信息？
- module.exports和exports的区别，它们之间的关系是什么？
CommonJS规范
众所周知，nodejs是基于CommonJS规范来实现，CommonJS规范主要有以下几点内容：
- 每个文件就是一个模块，有自己的作用域。在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见。
- 每个模块内部，module变量代表当前模块。这个变量是一个对象，它的exports属性（即module.exports）是对外的接口。加载某个模块，其实是加载该模块的module.exports属性。
- require方法用于加载模块
// moduleA.js
let name = "Node";
module.exports.str = name;
// moduleB.js
let multiplyBy2 = require('./moduleA');
let res = multiplyBy2.str;
console.log(res); // Node
看以上定义内容我们知道，CommonJS规范规定了每个模块内部都有module变量表示当前模块，使用exports导出模块内容以及require导入模块
既然一个文件就是一个模块,
既然想要使用模块必须先通过require()导入模块
所以可以推断出require()的作用其实就是读取文件
所以要想了解Node是如何实现模块的, 必须先了解如何执行读取到的代码
执行从文件中读取代码
我们都知道通过fs模块可以读取文件, 但是读取到的数据要么是二进制,
要么是字符串无论是二进制还是字符串都无法直接执行
但是我们知道如果是字符串, 在JS中是有办法让它执行的---使用eval 或者 new Function;
eval
通过eval执行代码
let str = "console.log('NodeJS模块原理')";
eval(str);
缺点: 存在依赖关系, 字符串可以访问外界数据,不安全
let name = "Node";
let str = "console.log(name)";
eval(str); // Node
new Function
通过new Function执行代码
let str = "console.log('NodeJS模块原理')";
let fn = new Function(str);
fn();
缺点: 存在依赖关系, 依然可以访问外界数据,不安全
let name = "Node";
let str = "console.log(name)";
let fn = new Function(str);
fn(); // Node
以上两种方法都有着明显的缺陷, 可以访问外部数据, 容易被别人注入代码, 有安全隐患
那么我们有没有方法, 做到既可以读取字符串的数据又比较安全, 答案是有的
NodeJS提供了一个vm-虚拟机模块, 这个模块中有两个方法就可以解决上面的问题
导入模块
const vm = require("vm");
runInThisContext
提供了一个安全的环境给我们执行字符串中的代码, 但是不能访问本地的变量, 可以访问全局的变量(也就是global上的变量)
let name = "Node";
let str = "console.log(name)";
vm.runInThisContext(str); // name is not defined
global.name = "Node";
let str = "console.log(name)";
vm.runInThisContext(str); // Node
runInNewContext
提供了一个安全的环境给我们执行字符串中的代码, 但是不能访问本地的变量, 也不能访问全局的变量(也就是global上的变量)
let name = "Node";
let str = "console.log(name)";
vm.runInNewContext(str); // name is not defined
global.name = "Node";
let str = "console.log(name)";
vm.runInNewContext(str); // name is not defined
这两个方法都可以执行字符串中的代码, 都不能访问本地变量, 但是runInThisContext可以访问全局变量, runInNewContext却不可以
我们知道了如何安全地执行字符串中的代码后, 接下来我们就可以自己来实现NodeJS的模块系统了, 但是在自己实现之前, 我们先来看一下官方是如何实现的
源码分析
1. 准备工作
在电脑中通过nvm安装低版本的Node.js(6.17.1), 因为新版本的代码中做了很多的优化, 不太利于初学者去阅读。
安装好后切换到这个版本
2.编写自定义模块, 并且引入模块
// 02-a.js
exports.str = "Node";
// 02-b.js
let aMoudle = require("./02-a.js");
console.log(aMoudle);
console.log(aMoudle.str);
3.断点调试
在let aMoudle = require("./02-a.js");这一行代码上打一个断点
- 进入到官方的require方法中
function require(path) {
return self.require(path);
}
- 通过Module对象的静态__load方法加载模块文件
Module.prototype.require = function(path) {
return Module._load(path, this, /* isMain */ false);
};
- 通过Module对象的静态_resolveFilename方法, 得到绝对路径并添加后缀名
var filename = Module._resolveFilename(request, parent, isMain);
- 根据路径判断是否有缓存, 如果没有就创建一个新的Module模块对象并缓存起来
var cachedModule = Module._cache[filename];
if (cachedModule) {
return cachedModule.exports;
}
var module = new Module(filename, parent);
Module._cache[filename] = module;
function Module(id, parent) {
this.id = id;
this.exports = {};
}
- 利用tryModuleLoad方法加载模块
tryModuleLoad(module, filename);
6.1 取出模块后缀
var extension = path.extname(filename);
6.2 根据不同后缀查找不同方法并执行对应的方法, 加载模块
Module._extensions[extension](this, filename);
6.3 如果是JSON就转换成对象
module.exports = JSON.parse(internalModule.stripBOM(content));
6.4 如果是JS就包裹一个函数
var wrapper = Module.wrap(content);
NativeModule.wrap = function(script) {
return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
}
NativeModule.wrapper = [
'(function (exports, require, module, __filename, __dirname) { ',
'\n});'
];
6.5 执行包裹函数之后的代码, 拿到执行结果(String -- Function)
var compiledWrapper = vm.runInThisContext(wrapper);
6.6 利用apply执行fn函数, 修改module.exports的值
var args = [this.exports, require, module, filename, dirname];
var result = compiledWrapper.call(this.exports, args);
6.7 返回module.exports
return module.exports;
手写Noe模块
02-a.js
exports.str = "Node";
person.json
{
"name": "zhangsan",
"gender": "male",
"age": "20"
}
module.js
const path = require("path");
const fs = require("fs");
const vm = require("vm");
class MyModule {
constructor(id){
this.id = id; // 保存当前模块的绝对路径
this.exports = {};
}
}
MyModule._cache = {};
MyModule._extensions = {
".js": function (module) {
// 1.读取JS代码
let script = fs.readFileSync(module.id);
// 2.将JS代码包裹到函数中
/*
(function (exports, require, module, __filename, __dirname) {
exports.str = "Node";
});
* */
let strScript = MyModule.wrapper[0] + script + MyModule.wrapper[1];
// 3.将字符串转换成JS代码
let jsScript = vm.runInThisContext(strScript);
// 4.执行转换之后的JS代码
jsScript.call(module.exports, module.exports);
},
".json": function (module) {
let json = fs.readFileSync(module.id);
let obj = JSON.parse(json);
module.exports = obj;
}
};
MyModule.wrapper = [
'(function (exports, require, module, __filename, __dirname) { ',
'\n});'
];
function myRequire(filePath) {
// 1.将转换的相对路径转换为绝对路径
let absPath = path.join(__dirname, filePath);
// 2.尝试从缓存中获取当前的模块
let cachedModule = MyModule._cache[absPath];
if (cachedModule){
return cachedModule.exports;
}
// 3.如果没有缓存就自己创建一个MyModule对象, 并缓存起来
let module = new MyModule(absPath);
MyModule._cache[absPath] = module;
// 4.利用tryModuleLoad方法加载模块
tryModuleLoad(module);
// 5.返回模块的exports
return module.exports;
}
function tryModuleLoad(module){
// 1.取出模块后缀
let extName = path.extname(module.id);
MyModule._extensions[extName](module);
}
let aMoudle = myRequire("./02-a.js");
console.log(aMoudle);
高频面试题
1. NodeJS中的this为什么是一个空对象?
因为所有的NodeJS文件在执行的时候都会被包裹到一个函数中, this都被修改为了空的module.exports
(function (exports, require, module, __filename, __dirname) {
// 我们编写的代码
// 所以说在这里面拿到的this就是 空的module.exports
});
compiledWrapper.call(module.exports, args);
2. NodeJS中为什么可以直接使用exports, require, module, __filename, __dirname
因为所有的NodeJS文件在执行的时候都会被包裹到一个函数中, 这些属性都被通过参数的形式传递过来了
var args = [module.exports, require, module, filename, dirname];
compiledWrapper.call(this.exports, args);
3. NodeJS中为什么不能直接给exports赋值, 而可以给module.exports赋值
exports = "Node";
假如给exports赋值为"Node"就相当于执行下面的代码
(function (exports, require, module, __filename, __dirname) {
exports = "Node";
});
jsScript.call(module.exports, module.exports);
return module.exports;
相当于
let exports = module.exports;
改变了exports的指向
exports = "Node";
return module.exports;
所以最后返回的module.exports并没有被修改, 还是一个空对象
4. 通过require导入包时候应该使用var/let还是const?
导入包的目的是使用包而不是修改包, 所以导入包时使用const接收
网友评论