bar
bar.js
bar.json
bar.node

function Module(id, parent) {
 this.id = id;
 this.exports = {};
 this.parent = parent;
 this.filename = null;
 this.loaded = false;
 this.children = [];
}

module.exports = Module;

var module = new Module(filename, parent);

// a.js

console.log('module.id: ', module.id);
console.log('module.exports: ', module.exports);
console.log('module.parent: ', module.parent);
console.log('module.filename: ', module.filename);
console.log('module.loaded: ', module.loaded);
console.log('module.children: ', module.children);
console.log('module.paths: ', module.paths);

$ node a.js

module.id: .
module.exports: {}
module.parent: null
module.filename: /home/ruanyf/tmp/a.js
module.loaded: false
module.children: []
module.paths: [ '/home/ruanyf/tmp/node_modules',
 '/home/ruanyf/node_modules',
 '/home/node_modules',
 '/node_modules' ]

// b.js

var a = require('./a.js');

$ node b.js

module.id: /home/ruanyf/tmp/a.js
module.exports: {}
module.parent: { object }
module.filename: /home/ruanyf/tmp/a.js
module.loaded: false
module.children: []
module.paths: [ '/home/ruanyf/tmp/node_modules',
 '/home/ruanyf/node_modules',
 '/home/node_modules',
 '/node_modules' ]

Module.prototype.require = function(path) {
 return Module._load(path, this);
};

Module._load = function(request, parent, isMain) {

 // 計(jì)算絕對(duì)路徑
 var filename = Module._resolveFilename(request, parent);

 // 第一步：如果有緩存，取出緩存
 var cachedModule = Module._cache[filename];
 if (cachedModule) {
  return cachedModule.exports;

 // 第二步：是否為內(nèi)置模塊
 if (NativeModule.exists(filename)) {
  return NativeModule.require(filename);
 }

 // 第三步：生成模塊實(shí)例，存入緩存
 var module = new Module(filename, parent);
 Module._cache[filename] = module;

 // 第四步：加載模塊
 try {
  module.load(filename);
  hadException = false;
 } finally {
  if (hadException) {
   delete Module._cache[filename];
  }
 }

 // 第五步：輸出模塊的exports屬性
 return module.exports;
};

Module._resolveFilename = function(request, parent) {

 // 第一步：如果是內(nèi)置模塊，不含路徑返回
 if (NativeModule.exists(request)) {
  return request;
 }

 // 第二步：確定所有可能的路徑
 var resolvedModule = Module._resolveLookupPaths(request, parent);
 var id = resolvedModule[0];
 var paths = resolvedModule[1];

 // 第三步：確定哪一個(gè)路徑為真
 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;
};

Module._findPath = function(request, paths) {

 // 列出所有可能的后綴名：.js，.json, .node
 var exts = Object.keys(Module._extensions);

 // 如果是絕對(duì)路徑，就不再搜索
 if (request.charAt(0) === '/') {
  paths = [''];
 }

 // 是否有后綴的目錄斜杠
 var trailingSlash = (request.slice(-1) === '/');

 // 第一步：如果當(dāng)前路徑已在緩存中，就直接返回緩存
 var cacheKey = JSON.stringify({request: request, paths: paths});
 if (Module._pathCache[cacheKey]) {
  return Module._pathCache[cacheKey];
 }

 // 第二步：依次遍歷所有路徑
 for (var i = 0, PL = paths.length; i < PL; i++) {
  var basePath = path.resolve(paths[i], request);
  var filename;

  if (!trailingSlash) {
   // 第三步：是否存在該模塊文件
   filename = tryFile(basePath);

   if (!filename && !trailingSlash) {
    // 第四步：該模塊文件加上后綴名，是否存在
    filename = tryExtensions(basePath, exts);
   }
  }

  // 第五步：目錄中是否存在 package.json 
  if (!filename) {
   filename = tryPackage(basePath, exts);
  }

  if (!filename) {
   // 第六步：是否存在目錄名 + index + 后綴名 
   filename = tryExtensions(path.resolve(basePath, 'index'), exts);
  }

  // 第七步：將找到的文件路徑存入返回緩存，然后返回
  if (filename) {
   Module._pathCache[cacheKey] = filename;
   return filename;
  }
 }

 // 第八步：沒有找到文件，返回false 
 return false;
};

require.resolve = function(request) {
 return Module._resolveFilename(request, self);
};

// 用法
require.resolve('a.js')
// 返回 /home/ruanyf/tmp/a.js

Module.prototype.load = function(filename) {
 var extension = path.extname(filename) || '.js';
 if (!Module._extensions[extension]) extension = '.js';
 Module._extensions[extension](this, filename);
 this.loaded = true;
};

Module._extensions['.js'] = function(module, filename) {
 var content = fs.readFileSync(filename, 'utf8');
 module._compile(stripBOM(content), filename);
};

Module._extensions['.json'] = function(module, filename) {
 var content = fs.readFileSync(filename, 'utf8');
 try {
  module.exports = JSON.parse(stripBOM(content));
 } catch (err) {
  err.message = filename + ': ' + err.message;
  throw err;
 }
};

Module.prototype._compile = function(content, filename) {
 var self = this;
 var args = [self.exports, require, self, filename, dirname];
 return compiledWrapper.apply(self.exports, args);
};

(function (exports, require, module, __filename, __dirname) {
 // 模塊源碼
});