源码解读
分类:计算机网络

2009年,Node.js 项目落地,全数模块一律为 CommonJS 格式。

2009年,Node.js 项目落地,全部模块一律为 CommonJS 格式。

迄今,Node.js 的模块货仓 npmjs.com ,已经寄放了15万个模块,个中绝大多数都以 CommonJS 格式。

时至前日,Node.js 的模块旅社 npmjs.com ,已经寄存了15万个模块,当中绝超过55%都是CommonJS 格式。

这种格式的宗旨正是 require 语句,模块通过它加载。学习 Node.js ,必学如何采用 require 语句。本文通过源码解析,详细介绍 require 语句的在这之中运营机制,帮你知道 Node.js 的模块机制。

这种格式的着力正是 require 语句,模块通过它加载。学习 Node.js ,必学如何运用 require 语句。本文通过源码剖判,详细介绍 require 语句的中间运转搭飞机制,帮你领悟 Node.js 的模块机制。

图片 1

图片 2

一、require() 的中央用法

一、require() 的中坚用法

解析源码在此以前,先介绍 require 语句的中间逻辑。倘令你只想询问 require 的用法,只看这一段就够了。

上边包车型客车内容翻译自《Node使用手册》。

当 Node 蒙受 require(X) 时,按上边包车型大巴依次管理。

(1)假若 X 是停放模块(比如 require('http')) 
  a. 再次来到该模块。 
  b. 不再继续实践。

(2)如果 X 以 "./" 或者 "/" 或者 "../" 开头 
  a. 依据 X 所在的父模块,鲜明 X 的相对路径。 
  b. 将 X 当成文件,依次查找上边文件,只要当中有三个存在,就赶回该文件,不再继续施行。

  • X
  • X.js
  • X.json
  • X.node

  c. 将 X 当成目录,依次查找上面文件,只要在那之中有三个留存,就回去该文件,不再继续实施。

  • X/package.json(main字段)
  • X/index.js
  • X/index.json
  • X/index.node

(3)如果 X 不带路线 
  a. 依据 X 所在的父模块,确定 X 恐怕的装置目录。 
  b. 依次在各样目录中,将 X 当成文件名或目录名加载。

(4) 抛出 "not found"

请看二个例证。

前段时间剧本文件 /home/ry/projects/foo.js 实行了 require('bar') ,那属于地点的第二种景况。Node 内部运营进度如下。

首先,显著 x 的相对路线或者是上边那几个职责,依次寻找每叁个索引。

/home/ry/projects/node_modules/bar
/home/ry/node_modules/bar
/home/node_modules/bar
/node_modules/bar

找寻时,Node 先将 bar 当成文件名,依次尝试加载下边那一个文件,只要有二个打响就重回。

bar
bar.js
bar.json
bar.node

设若都不成事,表明 bar 只怕是目录名,于是依次尝试加载上面这一个文件。

bar/package.json(main字段)
bar/index.js
bar/index.json
bar/index.node

如若在富有目录中,都无可奈何找到 bar 对应的文件或目录,就抛出一个荒谬。

浅析源码以前,先介绍 require 语句的中间逻辑。要是您只想打听 require 的用法,只看这一段就够了。

二、Module 构造函数

通晓当中逻辑今后,上边就来看源码。

require 的源码在 Node 的 lib/module.js 文件。为了有助于明白,本文引用的源码是简化过的,何况删除了原来的文章者的注释。

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);

地点代码中,Node 定义了一个构造函数 Module,全体的模块都以 Module 的实例。能够见见,当前模块(module.js)也是 Module 的贰个实例。

各类实例皆有本身的属性。上边通过一个例子,看看那些属性的值是什么样。新建贰个剧本文件 a.js 。

// 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' ]

能够见见,如果未有父模块,直接调用当前模块,parent 属性就是 null,id 属性正是叁个点。filename 属性是模块的相对路径,path 属性是叁个数组,满含了模块大概的岗位。其它,输出这一个剧情时,模块还未有任何加载,所以 loaded 属性为 false 。

新建另四个本子文件 b.js,让其调用 a.js 。

// b.js

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

运行 b.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' ]

地点代码中,由于 a.js 被 b.js 调用,所以 parent 属性指向 b.js 模块,id 属性和 filename 属性一致,都以模块的相对路线。

上面包车型客车开始和结果翻译自《Node使用手册》。

三、模块实例的 require 方法

种种模块实例都有一个 require 方法。

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

估摸,require 而不是全局性命令,而是每一个模块提供的八个里边方法,也正是说,唯有在模块内部能力利用 require 命令(独一的两样是 REPL 情状)。别的,require 其实内部调用 Module._load 方法。

上边来看 Module._load 的源码。

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

  //  计算绝对路径
  var filename = Module._resolveFilename(request, parent);

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

  // 第二步:是否为内置模块
  if (NativeModule.exists(filename)) {
    return NativeModule.require(filename);
  }

  // 第三步:生成模块实例,存入缓存
  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;
};

地点代码中,首先解析出模块的相对路线(filename),以它看做模块的识别符。然后,若是模块已经在缓存中,就从缓存抽取;假使不在缓存中,就加载模块。

因此,Module._load 的关键步骤是八个。

  • Module._resolveFilename() :明确模块的绝对路线
  • module.load():加载模块

复制代码 代码如下:

四、模块的相对路线

下面是 Module._resolveFilename 方法的源码。

Module._resolveFilename = function(request, parent) {

  // 第一步:如果是内置模块,不含路径返回
  if (NativeModule.exists(request)) {
    return request;
  }

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

  // 第三步:确定哪一个路径为真
  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.resolveFilename 方法内部,又调用了多个点子 Module.resolveLookupPaths() 和 Module._find帕特h() ,前边叁个用来列出大概的门路,前面一个用来认同哪三个路径为真。

为了简洁起见,这里只给出 Module._resolveLookup帕特hs() 的运维结果。

[   '/home/ruanyf/tmp/node_modules',
    '/home/ruanyf/node_modules',
    '/home/node_modules',
    '/node_modules' 
    '/home/ruanyf/.node_modules',
    '/home/ruanyf/.node_libraries',
     '$Prefix/lib/node' ]

上边的数组,正是模块全数希望的门径。基本上是,从脚下路径始于顶尖级向上寻找node_modules 子目录。最终那八个门路,主借使为了历史原因保持包容,实际三月经比较少用了。

有了恐怕的路子以往,上边正是 Module._findPath() 的源码,用来规定毕竟哪三个是没有错路径。

Module._findPath = function(request, paths) {

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

  // 如果是绝对路径,就不再搜索
  if (request.charAt(0) === '/') {
    paths = [''];
  }

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

  // 第一步:如果当前路径已在缓存中,就直接返回缓存
  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;
};

因而地点代码,就可以找到模块的相对路线了。

不常候在类型代码中,供给调用模块的相对路线,那么除了 module.filename ,Node 还提供叁个 require.resolve 方法,供外界调用,用于从模块名取到相对路线。

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

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

当 Node 境遇 require(X) 时,按上面包车型地铁次第管理。

五、加载模块

有了模块的相对路径,就能够加载该模块了。上面是 module.load 方法的源码。

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;
};

地点代码中,首先鲜明模块的后缀名,差异的后缀名对应分裂的加载方法。上面是 .js 和 .json 后缀名对应的管理格局。

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;
  }
};

这边只谈谈 js 文件的加载。首先,将模块文件读取成字符串,然后剥离 utf8 编码特有的BOM文件头,最终编写翻译该模块。

module._compile 方法用于模块的编写翻译。

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) {
  // 模块源码
});

也正是说,模块的加载实质上正是,注入exports、require、module多少个全局变量,然后实行模块的源码,然后将模块的 exports 变量的值输出。

(完)

(1)假如 X 是放手模块(比如 require('http'))
  a. 再次来到该模块。
   b. 不再继续推行。

(2)如果 X 以 "./" 或者 "/" 或者 "../" 开头
   a. 依据 X 所在的父模块,明确 X 的相对路线。
   b. 将 X 当成文件,依次查找上面文件,只要在那之中有三个存在,就回去该文件,不再继续试行。

 X
 X.js
 X.json
 X.node

  c. 将 X 当成目录,依次查找上边文件,只要在那之中有四个设有,就重临该公文,不再继续实践。

 X/package.json(main字段)
 X/index.js
 X/index.json
 X/index.node

(3)假使 X 不带路线
   a. 依据 X 所在的父模块,显明 X 可能的设置目录。
   b. 依次在每种目录中,将 X 当成文件名或目录名加载。

(4) 抛出 "not found"

请看多少个例证。

最近剧本文件 /home/ry/projects/foo.js 施行了 require('bar') ,那属于地点的第二种景况。Node 内部运维进度如下。

第一,明确 x 的相对路线只怕是下面那一个岗位,依次寻找每四个索引。

复制代码 代码如下:

/home/ry/projects/node_modules/bar
/home/ry/node_modules/bar
/home/node_modules/bar
/node_modules/bar

检索时,Node 先将 bar 当成文件名,依次尝试加载上面这一个文件,只要有二个得逞就赶回。

bar
bar.js
bar.json
bar.node

假若都不成功,表达 bar 大概是目录名,于是依次尝试加载上边这一个文件。

复制代码 代码如下:

bar/package.json(main字段)
bar/index.js
bar/index.json
bar/index.node

如若在装有目录中,都束手无策找到 bar 对应的公文或目录,就抛出叁个张冠李戴。

二、Module 构造函数

询问其中逻辑以往,上面就来看源码。

require 的源码在 Node 的 lib/module.js 文件。为了有助于掌握,本文援用的源码是简化过的,而且删除了原版的书文者的讲授。

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);

上边代码中,Node 定义了二个构造函数 Module,全数的模块都以 Module 的实例。能够看到,当前模块(module.js)也是 Module 的八个实例。

每种实例皆有谈得来的属性。下边通过一个例证,看看那几个属性的值是哪些。新建三个剧本文件 a.js 。

// 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' ]

能够见到,如果未有父模块,直接调用当前模块,parent 属性正是 null,id 属性正是三个点。filename 属性是模块的相对路线,path 属性是多个数组,饱含了模块恐怕的职位。另外,输出这一个内容时,模块还未有任何加载,所以 loaded 属性为 false 。

新建另二个剧本文件 b.js,让其调用 a.js 。

// b.js

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

运行 b.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' ]

上边代码中,由于 a.js 被 b.js 调用,所以 parent 属性指向 b.js 模块,id 属性和 filename 属性一致,都以模块的相对路线。

三、模块实例的 require 方法

每一个模块实例都有多个 require 方法。

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

想见,require 而不是全局性命令,而是各样模块提供的三个里面方法,也便是说,唯有在模块内部技术利用 require 命令(独一的不及是 REPL 情况)。别的,require 其实内部调用 Module._load 方法。

下边来看 Module._load 的源码。

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

 // 计算绝对路径
 var filename = Module._resolveFilename(request, parent);

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

 // 第二步:是否为内置模块
 if (NativeModule.exists(filename)) {
  return NativeModule.require(filename);
 }

 // 第三步:生成模块实例,存入缓存
 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;
};

地点代码中,首先剖判出模块的相对路径(filename),以它作为模块的识别符。然后,假诺模块已经在缓存中,就从缓存收取;如若不在缓存中,就加载模块。

因此,Module._load 的关键步骤是多少个。

复制代码 代码如下:

◾Module._resolveFilename() :鲜明模块的相对路线
◾module.load():加载模块

四、模块的相对路线

下面是 Module._resolveFilename 方法的源码。

Module._resolveFilename = function(request, parent) {

 // 第一步:如果是内置模块,不含路径返回
 if (NativeModule.exists(request)) {
  return request;
 }

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

 // 第三步:确定哪一个路径为真
 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.resolveFilename 方法内部,又调用了多个措施 Module.resolveLookup帕特hs() 和 Module._findPath() ,前面二个用来列出只怕的途径,后面一个用来确认哪一个门道为真。

为了简洁起见,这里只给出 Module._resolveLookupPaths() 的运营结果。

复制代码 代码如下:

[   '/home/ruanyf/tmp/node_modules',
    '/home/ruanyf/node_modules',
    '/home/node_modules',
    '/node_modules'
    '/home/ruanyf/.node_modules',
    '/home/ruanyf/.node_libraries',
     '$Prefix/lib/node' ]

地点的数组,便是模块全体希望的路子。基本上是,从当前路线始于一级级向上寻觅node_modules 子目录。最终那多个渠道,首借使为了历史由来保持兼容,实际末春经非常少用了。

有了大概的门路以往,上面便是 Module._findPath() 的源码,用来明确到底哪四个是科学路径。

Module._findPath = function(request, paths) {

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

 // 如果是绝对路径,就不再搜索
 if (request.charAt(0) === '/') {
  paths = [''];
 }

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

 // 第一步:如果当前路径已在缓存中,就直接返回缓存
 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;
};

通过地点代码,就能够找到模块的相对路线了。

神跡在档期的顺序代码中,需求调用模块的相对路线,那么除了 module.filename ,Node 还提供四个 require.resolve 方法,供外界调用,用于从模块名取到相对路线。

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

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

五、加载模块

有了模块的相对路线,就足以加载该模块了。上边是 module.load 方法的源码。

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;
};

地点代码中,首先分明模块的后缀名,不相同的后缀名对应区别的加载方法。上边是 .js 和 .json 后缀名对应的拍卖方法。

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;
 }
};

此地只谈谈 js 文件的加载。首先,将模块文件读取成字符串,然后剥离 utf8 编码特有的BOM文件头,最终编写翻译该模块。

module._compile 方法用于模块的编译。

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) {
 // 模块源码
});

相当于说,模块的加载实质上正是,注入exports、require、module四个全局变量,然后实践模块的源码,然后将模块的 exports 变量的值输出。

(完)

你大概感兴趣的篇章:

  • Node.js中require的劳作规律分析
  • node.js使用require()函数加载模块
  • node.js中的require使用详解
  • 轻易易行模拟node.js中require的加运载飞机制
  • Node.js中的require.resolve方法应用简单介绍

本文由正版必中一肖图发布于计算机网络,转载请注明出处:源码解读

上一篇:提高性能,JavaScript文档碎片操作实例分析 下一篇:详解JavaScript基于面向对象之继承,轻松学习Jav
猜你喜欢
热门排行
精彩图文