Nodejs源码解析之module

modulejs的导入

Require函数详解

module路径解析

module.js的导入

module.js是由node.js在Nodejs程序启动的时候导入的。module.js中使用的require函数是在node.js文件中定义的。 具体的代码在node.js中，代码分为两段：

// 程序启动时候，会利用NativeModule去require我们的module.js函数
// 下面会详细介绍NativeModule
var Module = NativeModule.require('module');
.............(省去)
} else {
// Main entry point into most programs:
// 这个就是文档中所说的主模块问题，也就是利用node app.js启动程序时候，
// app.js就是主模块，也就是module.js里面定义的runMain函数。
Module.runMain();
}

下面详细说明NativeModule的使用

// 对象构造函数
function NativeModule(id) {
// 文件名，自动加上了js后缀，说明其仅仅解析js的module文件
this.filename = id + '.js';
// 用于记录本模块的标志符
this.id = id;
// 模块的导出对象
this.exports = {};
// 是否导出标志符
this.loaded = false;
}
// 内部的模块， 具体可以查看 process.binding的用法
NativeModule._source = process.binding('natives');
// 用于做NativeModule的内部缓存
NativeModule._cache = {};
// 这个是在module.js中使用的require函数
NativeModule.require = function(id) {
// 特殊处理，如果是native_module，直接返回
if (id == 'native_module') {
return NativeModule;
}
// 查看是否有缓存，
var cached = NativeModule.getCached(id);
if (cached) {
// 如果有，直接返回导出的对象
return cached.exports;
}
// 是否在NativeModule中存在
if (!NativeModule.exists(id)) {
throw new Error('No such native module ' + id);
}
// 这个应该是和C/C++的系统模块交互
process.moduleLoadList.push('NativeModule ' + id);
// 生成一个新的NativeModule对象
var nativeModule = new NativeModule(id);
// 做缓存
nativeModule.cache();
// 编译模块
nativeModule.compile();
// 导出模块的对象
return nativeModule.exports;
};
// 查找是否有缓存
NativeModule.getCached = function(id) {
return NativeModule._cache[id];
}
// 查找id是否存在，从代码上可以看出NativeModule要求在c/c++代码中有体现
NativeModule.exists = function(id) {
return NativeModule._source.hasOwnProperty(id);
}
// 获取source
NativeModule.getSource = function(id) {
return NativeModule._source[id];
}
// 对于script的封装，这个是后续理解module，exports等的关键。任何的require
//一个文件或者模块其实就是将文件里面的内容，封装成一个函数
NativeModule.wrap = function(script) {
return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
};
// 具体的函数头和尾
NativeModule.wrapper = [
'(function (exports, require, module, __filename, __dirname) { ',
'\n});'
];
//编译
NativeModule.prototype.compile = function() {
var source = NativeModule.getSource(this.id);
source = NativeModule.wrap(source);
// 这个是javascript虚拟机的功能 后续会有详细介绍
var fn = runInThisContext(source, { filename: this.filename });
// 查看上述的wrap 函数定义，也就是说在module.js中使用的module
// 其实是NativeModule对象
// 使用的require函数，其实是NativeModule.require
fn(this.exports, NativeModule.require, this, this.filename);
// 模块已经导入
this.loaded = true;
};
// 增加cache
NativeModule.prototype.cache = function() {
NativeModule._cache[this.id] = this;
};

由于module模块的内容比较多，分如下重点函数进行源码分析，然后再分析帮助函数

Require函数详解

下面是require函数的源码，也就是我们通常用require(./test)时候，这里需要强调的是，require不是关键字，而是一个函数

// Loads a module at the given file path. Returns that module's
// `exports` property.
// 导入模块，并且返回模块的exports属性。
Module.prototype.require = function(path) {
// 参数检查，确保path不为空
assert(path, 'missing path');
// 参数检查，确保path为string类型
assert(util.isString(path), 'path must be a string');
// 直接调用_load函数返回，注意参数多了一个this，也就是本module的对象
return Module._load(path, this);
};

// Check the cache for the requested file.
// 1. If a module already exists in the cache: return its exports object.
// 2. If the module is native: call `NativeModule.require()` with the
//    filename and return the result.
// 3. Otherwise, create a new module for the file and save it to the cache.
//    Then have it load  the file contents before returning its exports
//    object.
// 上述的介绍翻译。
// 对要求的文件检查缓存，
// @request就是对应的要导入的file或者目录，
// @parent其实是谁导入了该模块，从上述的源码可以看出，其实是this。
// @isMain 标志是否为主文件，这里只有从node.js 调用的才是，其他都不是。
// 对于缓存，会做下面的事情：
// 1. 如果模块以及存在在缓存中，直接返回。
// 2. 如果模块是native的，直接调用NativeModule.require()并且返回。
// 3. 否则，创建一个新的module对象，保存在缓存中，并且导入文件内容，然后返回exports对象。
Module._load = function(request, parent, isMain) {
// 添加log，看谁导入了当前的模块
if (parent) {
debug('Module._load REQUEST  ' + (request) + ' parent: ' + parent.id);
}
//找到当前的需要解析的文件名，以后会详解_resolveFilename
var filename = Module._resolveFilename(request, parent);
// 步骤1：如果已经有的缓存，直接返回缓存的exports
var cachedModule = Module._cache[filename];
if (cachedModule) {
return cachedModule.exports;
}
// 步骤2：如果在自然模块中存在，直接使用自然模块进行解析
if (NativeModule.exists(filename)) {
// REPL is a special case, because it needs the real require.
if (filename == 'repl') {
var replModule = new Module('repl');
replModule._compile(NativeModule.getSource('repl'), 'repl.js');
NativeModule._cache.repl = replModule;
return replModule.exports;
}

debug('load native module ' + request);
return NativeModule.require(filename);
}
// 创建Module对象。
var module = new Module(filename, parent);
// 是否为主模块，
if (isMain) {
// 主模块的话，需要将当前的module赋值给process.mainModule
process.mainModule = module;
// 主模块的id特殊的赋值为"."
module.id = '.';
}
// 将创建的模块cache起来
Module._cache[filename] = module;
// 确保是否有异常
var hadException = true;
try {
// 做真正的导入模块的操作，下面会详解该函数
module.load(filename);
hadException = false;
} finally {
// 如果有异常，直接删除上述的缓存
if (hadException) {
delete Module._cache[filename];
}
}
// 返回新创建模块的exports
return module.exports;
};

// Given a file name, pass it to the proper extension handler.
// 指定一个文件名，导入模块，调用适当扩展处理函数，当前主要是js，json，和node
Module.prototype.load = function(filename) {
//增加log，当前导入什么文件，id是什么
debug('load ' + JSON.stringify(filename) +
' for module ' + JSON.stringify(this.id));
// 确保当前模块没有被载入
assert(!this.loaded);
// 赋值当前模块的文件名
this.filename = filename;
// 当前的path
this.paths = Module._nodeModulePaths(path.dirname(filename));
// 当前文件的后缀
var extension = path.extname(filename) || '.js';
// 确认默认的后缀都*.js
if (!Module._extensions[extension]) extension = '.js';
// 根据后缀的解析函数来做解析
Module._extensions[extension](this, filename);
this.loaded = true;
};

下面是nodejs支持的三种后缀：

// Native extension for .js
// js后缀的处理
Module._extensions['.js'] = function(module, filename) {
//直接同步的读入文件的内容。
var content = fs.readFileSync(filename, 'utf8');
// 然后调用_compile进行编译。下面会分析该函数
module._compile(stripBOM(content), filename);
};

// Native extension for .json
// 对于json文件的处理
Module._extensions['.json'] = function(module, filename) {
//直接同步的读入文件的内容。
var content = fs.readFileSync(filename, 'utf8');
try {
// 直接将模块的exports赋值为json文件的内容
module.exports = JSON.parse(stripBOM(content));
} catch (err) {
// 异常处理
err.message = filename + ': ' + err.message;
throw err;
}
};
//node文件的打开处理，通常为C/C++文件。
Module._extensions['.node'] = process.dlopen;

下面就分析最后的一个函数_compile:
// Run the file contents in the correct scope or sandbox. Expose
// the correct helper variables (require, module, exports) to
// the file.
// Returns exception, if any.
// 这个函数会给出require, module, exports等帮助变量给文件
// @content 主要是js文件的主要内容
// @filename 是js文件的文件名
Module.prototype._compile = function(content, filename) {
// self就是一个帮助变量，代表的this
var self = this;
// remove shebang
// 去掉一些注释（shebang）
content = content.replace(/^\#\!.*/, '');
// 其实模块中的require就是这个函数
// 其仅仅是一个对module中的require函数的封装。
function require(path) {
return self.require(path);
}
//resolve 函数，这个会解释文档中的module导入的路径问题，是单个文件，目录还是模块
require.resolve = function(request) {
return Module._resolveFilename(request, self);
};
// 禁止使用require中的paths路径
Object.defineProperty(require, 'paths', { get: function() {
throw new Error('require.paths is removed. Use ' +
'node_modules folders, or the NODE_PATH ' +
'environment variable instead.');
}});
//注意require.main就是主模块
require.main = process.mainModule;

// Enable support to add extra extension types
// 将Module._extensions赋值给require
require.extensions = Module._extensions;
require.registerExtension = function() {
throw new Error('require.registerExtension() removed. Use ' +
'require.extensions instead.');
};
//将缓存也赋值给require
// require一会是函数，一会又像是对象，其实都是对象：）
require.cache = Module._cache;

// 获取当前的文件的路径
var dirname = path.dirname(filename);
// 当NODE_MODULE_CONTEXTS为1的时候才可以调用，也就是说，所有的模块都在一个环境中，无需
// 模块来，这个好像通常情况下不会被执行。
// Module._contextLoad = (+process.env['NODE_MODULE_CONTEXTS'] > 0);
if (Module._contextLoad) {
if (self.id !== '.') {
debug('load submodule');
// not root module
var sandbox = {};
for (var k in global) {
sandbox[k] = global[k];
}
sandbox.require = require;
sandbox.exports = self.exports;
sandbox.__filename = filename;
sandbox.__dirname = dirname;
sandbox.module = self;
sandbox.global = sandbox;
sandbox.root = root;

return runInNewContext(content, sandbox, { filename: filename });
}

debug('load root module');
// root module
global.require = require;
global.exports = self.exports;
global.__filename = filename;
global.__dirname = dirname;
global.module = self;

return runInThisContext(content, { filename: filename });
}

// create wrapper function
// 这里的wrap函数就是node.js中的函数，会将文件中的内容封装成一个函数。
var wrapper = Module.wrap(content);
// 编译内容，返回函数
var compiledWrapper = runInThisContext(wrapper, { filename: filename });
// 处理debug模式，
if (global.v8debug) {
if (!resolvedArgv) {
// we enter the repl if we're not given a filename argument.
if (process.argv[1]) {
resolvedArgv = Module._resolveFilename(process.argv[1], null);
} else {
resolvedArgv = 'repl';
}
}

// Set breakpoint on module start
if (filename === resolvedArgv) {
global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0);
}
}
// 直接调用wrapper函数，将module模块中的exports，本函数中的require，
//self也就是新创建的module作为参数传递给模块，进行执行。
// filename, dirname作为参数传递过去
// 这就是为什么我们可以直接在module文件中，直接访问exports, module, require函数的原因
var args = [self.exports, require, self, filename, dirname];
return compiledWrapper.apply(self.exports, args);
};

所以，从上面的源码分析中，我们知道了缓存是如何实现的， module中的变量如exports，id，filename是如何能得到访问的。[/code]

module路径解析

这里先可以看一下官方文章中的内容：

require(X) from module at path Y
1. If X is a core module, // 如果是核心模块，
a. return the core module // 直接返回核心模块，这里的核心模块是指nodejs下lib的内容
b. STOP 返回
2. If X begins with './' or '/' or '../' // 如果文件以 "./", "/",或者 "../"形式，
a. LOAD_AS_FILE(Y + X) // 导入一个文件 返回，如何处理导入文件
b. LOAD_AS_DIRECTORY(Y + X) // 导入一个目录，返回 如何导入目录，看后面
3. LOAD_NODE_MODULES(X, dirname(Y)) // 导入一个NODE_MODULE，返回。
4. THROW "not found" // 上述都没找到，直接排出没找到的异常。

LOAD_AS_FILE(X) // 导入一个文件按
1. If X is a file, load X as JavaScript text.  STOP  // 如果X是一个文件，作为js文件导入，直接返回。直接停止
2. If X.js is a file, load X.js as JavaScript text.  STOP //加上js后缀为一个文件，直接作为js文件导入 直接停止
3. If X.json is a file, parse X.json to a JavaScript Object.  STOP//加上json后缀为一个文件，直接作为json文件导入 直接停止
4. If X.node is a file, load X.node as binary addon.  STOP//加上node后缀为一个文件，直接作为c/c++ addon文件导入 直接停止

LOAD_AS_DIRECTORY(X) 如何导入一个目录的处理方式
1. If X/package.json is a file, // 查找X/package.json是否存在
a. Parse X/package.json, and look for "main" field. //查找json file中是否有main
b. let M = X + (json main field) // 生成新的文件
c. LOAD_AS_FILE(M) // 作为文件导入。
2. If X/index.js is a file, load X/index.js as JavaScript text.  STOP // 查看是否存在 X/index.js，如果存在，作为js文件导入
3. If X/index.json is a file, parse X/index.json to a JavaScript object. STOP // 查看是否存在 X/index.json，如果存在，导入json文件作为js对象
4. If X/index.node is a file, load X/index.node as binary addon.  STOP// 查看是否存在 X/index.node，如果存在，导入c/c++的 addon导入

LOAD_NODE_MODULES(X, START) // 导入node_module的步骤
1. let DIRS=NODE_MODULES_PATHS(START) // 返回一个文件目录内容
2. for each DIR in DIRS:       // 对于目录里的内容
a. LOAD_AS_FILE(DIR/X)      // 作为文件导入。 作为文件导入，查看LOAD_AS_FILE
b. LOAD_AS_DIRECTORY(DIR/X) // 或者作为一个目录导入， 查看LOAD_AS_DIRECTORY

// 请注意，这里仅仅是说还是作为一个具体的文件或者目录，如果有一个找到了，就需要停止，而不是真的要导入文件文件里面的所有内容

NODE_MODULES_PATHS(START) // 具体NODE_MODULES文件目录算法
1. let PARTS = path split(START)
2. let I = count of PARTS - 1
3. let DIRS = []
4. while I >= 0,
a. if PARTS[I] = "node_modules" CONTINUE
c. DIR = path join(PARTS[0 .. I] + "node_modules")
b. DIRS = DIRS + DIR
c. let I = I - 1
5. return DIRS

基本的思想都在文档中做了详细的说明， 那么下面分析源代码是如何实现的。废话少说，直接源代码分析：

// 这个函数就是在load的时候调用的，也就是说其负责具体filename的文件查找。
// 所以，从这里可以看出，无论怎么处理，require仅仅能导入的是一个文件模块，不能是一个目录，
// 有目录的说法，仅仅是因为可以在目录上查找具体的文件。这也就是文档中所说的文件和目录的一一对应关系
Module._resolveFilename = function(request, parent) {
//如果是NativeModule中已经存在，直接用，这个其实就是core 模块，文档中的第一种情况
if (NativeModule.exists(request)) {
return request;
}
// 根据文件名称，调用_resolveLookupPaths来查找具体的文件模块
var resolvedModule = Module._resolveLookupPaths(request, parent);
// 上述返回的id
var id = resolvedModule[0];
// 上述返回的具体的目录文件夹
var paths = resolvedModule[1];

// look up the filename first, since that's the cache key.
// 输出具体的id和paths
debug('looking for ' + JSON.stringify(id) +
' in ' + JSON.stringify(paths));
// 找到具体的文件名称，以返回。
var filename = Module._findPath(request, paths);
// 处理文件找不到的情况
if (!filename) {
var err = new Error("Cannot find module '" + request + "'");
err.code = 'MODULE_NOT_FOUND';
throw err;
}
// 返回具体的文件
return filename;
};
// 从上面的文档可以看出，在处理核心模块后，其是依靠_resolveLookupPaths和_findPath这两个
// 帮助函数来查找具体的文件模块。
// _resolveLookupPaths： 该函数用于查找当前文件“可能的路径”
// _findPath： 根据上述的路径,根据优先级选择一个具体的文件，如官方文档中的文件

Module._resolveLookupPaths = function(request, parent) {
//依然先检查核心模块
if (NativeModule.exists(request)) {
return [request, []];
}
// 查找request的标志符，如果不以"./" 或者'..'开头
var start = request.substring(0, 2);
if (start !== './' && start !== '..') {
// 这种情况直接返回nodejs系统路径modulePaths，这个是在Module._initPaths 函数中设置的，
// 有兴趣可以自己分析一下，很简单的函数
var paths = modulePaths;
if (parent) {
// 设置一下父亲的路径，其实就是谁导入了当前模块
if (!parent.paths) parent.paths = [];
paths = parent.paths.concat(paths);
}
//直接返回
return [request, paths];
}

// with --eval, parent.id is not set and parent.filename is null
// 处理父亲模块为空的情况，这种情况我认为一般就是主模块
if (!parent || !parent.id || !parent.filename) {
// make require('./path/to/foo') work - normally the path is taken
// from realpath(__filename) but with eval there is no filename
// 生成新的目录， 在系统目录modulePaths，当前目录和"node_modules"作为候选的路径
// 对于node_modules，可以参考_nodeModulePaths函数。
var mainPaths = ['.'].concat(modulePaths);
mainPaths = Module._nodeModulePaths('.').concat(mainPaths);
return [request, mainPaths];
}

// Is the parent an index module?
// We can assume the parent has a valid extension,
// as it already has been accepted as a module.
// 处理父亲模块是否为index模块，
var isIndex = /^index\.\w+?$/.test(path.basename(parent.filename));
var parentIdPath = isIndex ? parent.id : path.dirname(parent.id);
// 返回request中的具体的id
var id = path.resolve(parentIdPath, request);

// make sure require('./path') and require('path') get distinct ids, even
// when called from the toplevel js file
// 确保require('./path') and require('path') 的id不一样。应该会做不同的缓存，所以，我们
if (parentIdPath === '.' && id.indexOf('/') === -1) {
id = './' + id;
}

debug('RELATIVE: requested:' + request +
' set ID to: ' + id + ' from ' + parent.id);
//返回id和具体的父亲模块的文件夹
//注意： 也就是说，当我们以"./" 等方式require是，都是以当前父模块为对象路径的
return [id, [path.dirname(parent.filename)]];
};

接下来分析一下：_findPath

// 从候选路径中选择
Module._findPath = function(request, paths) {
// 等到具体的文件扩展，现在有js,json 和node
var exts = Object.keys(Module._extensions);
//如果以绝对路径开头，直接重置可选路径，所以这个windows下和linux下应该不一样，
//这点应该是对linux来说的，所以，我们最好不要以/开头导入模块
if (request.charAt(0) === '/') {
paths = [''];
}

var trailingSlash = (request.slice(-1) === '/');
// 这里是做文件扫描的cache，防止重复查找
var cacheKey = JSON.stringify({request: request, paths: paths});
if (Module._pathCache[cacheKey]) {
// 如果cache已经有了，直接返回
return Module._pathCache[cacheKey];
}

// For each path
// 从每个候选路径中查找文件
for (var i = 0, PL = paths.length; i < PL; i++) {
var basePath = path.resolve(paths[i], request);
var filename;

if (!trailingSlash) {
// try to join the request to the path
// 尝试一下当前文件是否存在
filename = tryFile(basePath);
// 尝试一下当前文件加上后缀文件是否存在
if (!filename && !trailingSlash) {
// try it with each of the extensions
filename = tryExtensions(basePath, exts);
}
}
// 尝试一下当前的package.json文件是否存在
if (!filename) {
filename = tryPackage(basePath, exts);
}
// 尝试一下index文件加上后缀是否存在
if (!filename) {
// try it with each of the extensions at "index"
filename = tryExtensions(path.resolve(basePath, 'index'), exts);
}

if (filename) {
// 增加到文件缓存中
Module._pathCache[cacheKey] = filename;
return filename;
}
}
return false;
};

// 所以从这里可以看出，对于具体的文件的优先级：
// 1. 具体文件。
// 2. 加上后缀。
// 3. package.json
// 4  index加上后缀
// 候选路径以当前文件夹，nodejs系统文件夹和node_module中的文件夹为候选，以上述顺序找到任意一个，
// 就直接返回

还有一些帮助函数，如readPackage， tryPackage，tryFile，_initPaths没有做详细的说明。

上述就是module的全部重要的源码说明。