nodejs module.export require 原理分析

   大部分实现在module.js中，按照顺序来看： 首先调用require('xx')的时候内部调用了Module._load(path, parent) :

Module.prototype.require = function(path) {

assert(path, 'missing path');

assert(util.isString(path), 'path must be a string');

return Module._load(path, this);

};

       至于我们平时调用的require方法是不是就是这个Module原型上的require在稍后就可以确认。 

      _load函数里处理了模块的缓存逻辑，这个大家知道下就行，接下来主要是这段逻辑

var module = new Module(filename, parent);

if (isMain) {

process.mainModule = module;

module.id = '.';

}

Module._cache[filename] = module;

var hadException = true;

try {

module.load(filename);

hadException = false;

} finally {

if (hadException) {

delete Module._cache[filename];

}

} 

return module.exports;

 

    可以看到try块中调用了module.load(file)方法，然后调用完就返回了module对象的exports属性，那继续查看load(file)方法是怎么加载这个file并且赋值给module.exports。

Module.prototype.load = function(filename) {

debug('load ' + JSON.stringify(filename) +

' for module ' + JSON.stringify(this.id));

assert(!this.loaded);

this.filename = filename;

this.paths = Module._nodeModulePaths(path.dirname(filename));

var extension = path.extname(filename) || '.js';

if (!Module._extensions[extension]) extension = '.js';

Module._extensions[extension](this, filename);

this.loaded = true;

};

     直接看倒数4行，这几行就是根据要require的文件后缀来进行不同方法分发，我们这里就看最常见的对js文件的处理逻辑，其他后缀还支持'.node','.json'等。   

// Native extension for .js

Module._extensions['.js'] = function(module, filename) {

var content = fs.readFileSync(filename, 'utf8');

module._compile(stripBOM(content), filename);

};

    对.js文件，就是直接读取了这个文件的文本内容做一些字符处理，然后调用_compile 方法，好了，马上就到终点了，直接看_compile(content,filename)方法。

     _compile方法内容较长，但大部分不用特别深究，不影响理解require的逻辑。大致做了以下事情： 构建一个require变量

Module.prototype._compile = function(content, filename) {

var self = this;

// remove shebang

content = content.replace(/^\#\!.*/, '');

function require(path) {

return self.require(path);

}

require.resolve = function(request) {

return Module._resolveFilename(request, self);

};

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 = process.mainModule;

// Enable support to add extra extension types

require.extensions = Module._extensions;

require.registerExtension = function() {

throw new Error('require.registerExtension() removed. Use ' +

'require.extensions instead.');

};

require.cache = Module._cache;

    还记得一开始的问题么，这个require对象就是Module.require,其实这个require对象就是我们平时调用的require('xxx')所用的那个。

      然后有一段根据配置决定模块加载方式的，可以先不用看，因为默认不走这段逻辑，未避免分散注意力，这里就不贴了，有兴趣可以自己看环境变量：NODE_MODULE_CONTEXTS。

       接下来才终于到了真正要进行动手装载模块的时候了，没几行代码：

var wrapper = Module.wrap(content);

    这个wrap方法调用的是NativeModule.wrap方法，至于NativeModule.wrap方法究竟是干嘛的可看node.js源码：     

NativeModule.wrap = function(script) {

return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];

};

NativeModule.wrapper = [

'(function (exports, require, module, __filename, __dirname) { ',

'\n});'

];

      这个wrap方法非常重要！，直接解释了require核心是怎么实现的，其实就是把require的那个js文件的代码文本包在一个匿名函数体里。再看下这个自匿名函数的参数，也就是每个js模块中能直接访问到的变量。

       接下去看：

var compiledWrapper = runInThisContext(wrapper, { filename: filename });

      这里调用了vm模块的runInThisContext，注意，这里并没有执行模块的代码哦，这里只是执行了wrap方法，这句运行完其实只是获得了一个匿名函数对象（之前只是代码文本）。

       接下去才是真正执行这个匿名函数。

var args = [self.exports, require, self, filename, dirname];

return compiledWrapper.apply(self.exports, args);

       对应下这里的参数，这里可以很简单发现，首先每个模块的this就是module.exports（apply的第一个参数）, 其次exports就是module对象上的exports,同一个东西。所以这里可以直接弄明白exports和module的关系了，可以直接在exports上加东西，或者直接换一个。然后传入的require就是_compile方法刚开始创建的那个require方法，执行逻辑是一致的，所以提供了模块加载的传递性。
所以在每个模块中直接去修改module对象上的exports就决定了最终模块返回的结果。

       总结下，上面介绍的过程主要是最常见的加载非本地js模块的逻辑流程。根据代码可以知道每个模块中可以访问到的5个变量。了解了这些后对node中基本的module加载应该没不存在其他很大的疑惑了。