js零起点开发,js模块机制
分类:新闻中心

如果我们两次导入它:

Node.js模块加载详解,node.js模块详解

JavaScript是世界上使用频率最高的编程语言之一,它是Web世界的通用语言,被所有浏览器所使用。JavaScript的诞生要追溯到Netscape那个时代,它的核心内容被仓促的开发出来,用以对抗Microsoft,参与当时白热化的浏览器大战。由于过早的发布,无可避免的造成了它的一些不太好的特性。

尽管它的开发时间很短,但是JavaScript依然具备了很多强大的特性,不过,每个脚本共享一个全局命名空间这个特性除外。

一旦Web页面加载了JavaScript代码,它就会被注入到全局命名空间,会和其他所有已加载的脚本公用同一个地址空间,这会导致很多安全问题,冲突,以及一些常见问题,让bug即难以跟踪又很难解决。

不过谢天谢地,Node为服务器端JavaScript定了一些规范,还实现了CommonJS的模块标准,在这个标准里,每个模块有自己的上下文,和其他模块相区分。这意味着,模块不会污染全局作用域,因为根本就没有所谓的全局作用域,模块之间也不会相互干扰。

本章,我们将了解几种不同的模块以及如何加载它们。

把代码拆分成一系列定义良好的模块可以帮你掌控你的应用程序,下面我们将学习如何创建和使用你自己的模块。

了解Node如何加载模块

Node里,可以通过文件路径来引用模块,也可以通过模块名引用,如果用名称引用非核心模块,Node最终会把模块名影射到对应的模块文件路径。而那些包含了核心函数的核心模块,会在Node启动时被预先加载。

非核心模块包括使用NPM(Node Package Manager)安装的第三方模块,以及你或你的同事创建的本地模块。

每个被当前脚本导入的模块都会向程序员暴露一组公开API,使用模块前,需要用require函数来导入它,像这样:

复制代码 代码如下:

var module = require(‘module_name')

上面的代码会导入一个名为module_name的模块,它可能是个核心模块,也可以是用NPM安装的模块,require函数返回一个包含模块所有公共API的对象。随模块的不同,返回的对象可能是任何JavaScript值,可以是一个函数,也可以是个包含了一系列属性(函数,数组或者任何JavaScript对象)的对象。

导出模块

CommonJS模块系统是Node下文件间共享对象和函数的唯一方式。对于一个很复杂的程序,你应该把一些类,对象或者函数重构成一系列良好定义的可重用模块。对于模块使用者来说,模块仅对外暴露出那些你指定的代码。

在下面的例子里你将会了解到,在Node里文件和模块是一一对应的,我们创建了一个叫circle.js的文件,它仅对外导出了Circle构造函数。

复制代码 代码如下:

function Circle(x, y, r) {

       function r_squared() {

              return Math.pow(r, 2);

       }

       function area() {

              return Math.PI * r_squared();

       }

       return {area: area};

}

module.exports = Circle;

代码里最重要的是最后一行,它定义了模块对外导出了什么内容。module是个特殊的变量,它代表当前模块自身,而module.exports是模块对外导出的对象,它可以是任何对象,在这个例子里,我们把Circle的构造函数导出了,这样模块使用者就可以用这个模块来创建Circle实例。

你也可以导出一些复杂的对象,module.exports被初始化成一个空对象,你把任何你想暴露给外界的内容,作为module.exports对象的属性来导出。比如,你设计了一个模块,它对外暴露了一组函数:

复制代码 代码如下:

                  function printA() {

         console.log('A');

}

function printB() {

         console.log('B');

}

function printC() {

         console.log('C');

}

module.exports.printA = printA;

module.exports.printB = printB;

module.exports.pi = Math.PI;

这个模块导出了两个函数(printA和printB)和一个数字(pi),调用代码看起来像这样:

复制代码 代码如下:

var myModule2 = require('./myModule2');

myModule2.printA(); // -> A

myModule2.printB(); // -> B

console.log(myModule2.pi); // -> 3.141592653589793

加载模块

前面提到过,你可以使用require函数来加载模块,不用担心在代码里调用require会影响全局命名空间,因为Node里就没有全局命名空间这个概念。如果模块存在且没有任何语法或初始化错误,require函数就会返回这个模块对象,你还可以这个对象赋值给任何一个局部变量。

模块有几种不同的类型,大概可以分为核心模块,本地模块和通过NPM安装的第三方模块,根据模块的类型,有几种引用模块的方式,下面我们就来了解下这些知识。

加载核心模块

Node有一些被编译到二进制文件里的模块,被称为核心模块,它们不能通过路径来引用,只能用模块名。核心模块拥有最高的加载优先级,即使已经有了一个同名的第三方模块,核心模块也会被优先加载。

比如,如果你想加载和使用http核心模块,可以这样做:

复制代码 代码如下:

         var http = require('http');

这将返回一个包含了http模块对象,它包含了Node API文档里定义的那些htpp模块的API。

加载文件模块

你也可以使用绝对路径从文件系统里加载模块:

复制代码 代码如下:

var myModule = require('/home/pedro/my_modules/my_module');

也可以用一个基于当前文件的相对路径:

复制代码 代码如下:

var myModule = require('../my_modules/my_module');

var myModule2 = require('./lib/my_module_2');

注意上面的代码,你可以省略文件名的扩展名,如果Node找不到这个文件,会尝试在文件名后加上js后缀再次查找(译者注:其实除了js,还会查找json和node,具体可以看官网文档),因此,如果在当前目录下存在一个叫my_module.js的文件,会有下面两种加载方式:

复制代码 代码如下:

var myModule = require('./my_module');

var myModule = require('./my_module.js');

加载目录模块

你还可以使用目录的路径来加载模块:

复制代码 代码如下:

var myModule = require('./myModuleDir');

Node会假定这个目录是个模块包,并尝试在这个目录下搜索包定义文件package.json。

如果没找到,Node会假设包的入口点是index.js文件(译者注:除了index.js还会查找index.node,.node文件是Node的二进制扩展包,具体见官方文档),以上面代码为例,Node会尝试查找./myModuleDir/index.js文件。

反之,如果找到了package.json文件,Node会尝试解析它,并查找包定义里的main属性,然后把main属性的值当作入口点的相对路径。以本例来说,如果package.json定义如下:

复制代码 代码如下:

                   {

                            "name" : "myModule",

                            "main" : "./lib/myModule.js"

                   }

Node就会尝试加载./myModuleDir/lib/myModule.js文件

从node_modules目录加载

如果require函数的参数不是相对路径,也不是核心模块名,Node会在当前目录的node_modules子目录下查找,比如下面的代码,Node会尝试查找文件./node_modules/myModule.js:

复制代码 代码如下:

var myModule = require('myModule.js');

如果没找到,Node会继续在上级目录的node_modules文件夹下查找,如果还没找到就继续向上层目录查找,直到找到对应的模块或者到达根目录。

你可以使用这个特性来管理node_modules目录的内容或模块,不过最好还是把模块的管理任务交给NPM(见第一章),本地node_modules目录是NPM安装模块的默认位置,这个设计把Node和NPM关联在了一起。通常,作为开发人员不必太关心这个特性,你可以简单的使用NPM安装,更新和删除包,它会帮你维护node_modules目录

缓存模块

模块在第一次成功加载后会被缓存起来,就是说,如果模块名被解析到同一个文件路径,那么每次调用require(‘myModule')都确切地会返回同一个模块。

比如,有一个叫my_module.js的模块,包含下面的内容:

复制代码 代码如下:

console.log('module my_module initializing...');

module.exports = function() {

         console.log('Hi!');

};

console.log('my_module initialized.');

然后用下面的代码加载这个模块:

复制代码 代码如下:

var myModuleInstance1 = require('./my_module');

它会产生下面的输出:

复制代码 代码如下:

module my_module initializing...

my_module initialized

如果我们两次导入它:

复制代码 代码如下:

var myModuleInstance1 = require('./my_module');

var myModuleInstance2 = require('./my_module');

输出依然是:

复制代码 代码如下:

module my_module initializing...

my_module initialized

也就是说,模块的初始化代码仅执行了一次。当你构建自己的模块时,如果模块的初始化代码里含有可能产生副作用的代码,一定要特别注意这个特性。

小结

Node取消了JavaScript的默认全局作用域,转而采用CommonJS模块系统,这样你可以更好的组织你的代码,也因此避免了很多安全问题和bug。可以使用require函数来加载核心模块,第三方模块,或从文件及目录加载你自己的模块

还可以用相对路径或者绝对路径来加载非核心模块,如果把模块放到了node_modules目录下或者对于用NPM安装的模块,你还可以直接使用模块名来加载。

 译者注:

建议读者把官方文档的模块章节阅读一遍,个人感觉比作者讲得更清晰明了,而且还附加了一个非常具有代表性的例子,对理解Node模块加载会很有很大帮助。下面把那个例子也引用过来:

复制代码 代码如下:

用require(X) 加载路径Y下的模块

  1. 如果X是核心模块,

   a. 加载并返回核心模块

   b. 结束

  1. 如果X以 './' or '/' or '../ 开始'

   a. LOAD_AS_FILE(Y + X)

   b. LOAD_AS_DIRECTORY(Y + X)

  1. LOAD_NODE_MODULES(X, dirname(Y))

  2. 抛出异常:"not found"

LOAD_AS_FILE(X)

  1. 如果X是个文件,把 X作为JavaScript 脚本加载,加载完毕后结束

  2. 如果X.js是个文件,把X.js 作为JavaScript 脚本加载,加载完毕后结束

  3. 如果X.node是个文件,把X.node 作为Node二进制插件加载,加载完毕后结束

LOAD_AS_DIRECTORY(X)

  1. 如果 X/package.json文件存在,

   a. 解析X/package.json, 并查找 "main"字段.

   b. 另M = X + (main字段的值)

   c. LOAD_AS_FILE(M)

  1. 如果X/index.js文件存在,把 X/index.js作为JavaScript 脚本加载,加载完毕后结束

  2. 如果X/index.node文件存在,把load X/index.node作为Node二进制插件加载,加载完毕后结束

LOAD_NODE_MODULES(X, START)

  1. 另DIRS=NODE_MODULES_PATHS(START)

  2. 对DIRS下的每个目录DIR做如下操作:

   a. LOAD_AS_FILE(DIR/X)

   b. LOAD_AS_DIRECTORY(DIR/X)

NODE_MODULES_PATHS(START)

  1. 另PARTS = path split(START)

  2. 另ROOT = index of first instance of "node_modules" in PARTS, or 0

  3. 另I = count of PARTS - 1

  4. 另DIRS = []

  5. while I > ROOT,

   a. 如果 PARTS[I] = "node_modules" 则继续后续操作,否则下次循环

   c. DIR = path join(PARTS[0 .. I] + "node_modules")

   b. DIRS = DIRS + DIR

   c. 另I = I - 1

  1. 返回DIRS

index.js

模块对象

在每个模块中,module 的自由变量是一个指向表示当前模块的对象的引用。 为了方便,module.exports 也可以通过全局模块的 exports 对象访问。 module 实际上不是全局的,而是每个模块本地的。

  • module.exports 对象是由模块系统创建的。 将期望导出的对象赋值给module.exports使他成为某个类的实例
    将期望的对象赋值给 exports 会简单地重新绑定到本地 exports 变量上,这可能不是期望的
  • module.children被该模块引用的模块对象数组。
  • module.filename为模块的完全解析后的文件名。
  • module.id是模块的标识符。 通常是完全解析后的文件名。
  • module.loaded表示模块是否加载完成或者已经加载完毕的布尔值
  • module.parent<object>为最先引用的模块

JavaScript是世界上使用频率最高的编程语言之一,它是Web世界的通用语言,被所有浏览器所使用。JavaScript的诞生要追溯到Netscape那个时代,它的核心内容被仓促的开发出来,用以对抗Microsoft,参与当时白热化的浏览器大战。由于过早的发布,无可避免的造成了它的一些不太好的特性。

怎看Nodejs的外部模块是否安装好了?

npm install  

JavaScript是世界上使用频率最高的编程语言之一,它是Web世界的通用语言,被所有浏览器所使用。JavaS...

当 foo 包中有代码 require('bar') 时,它会得到符号链接至/usr/lib/node/foo/1.2.3/node_modules/bar 的版本。然后,当 bar 包调用 require('quux') 时,它会得到符号链接至 /usr/lib/node/bar/4.3.2/node_modules/quux 的版本。

Node.js 有一个简单的模块加载系统。 在 Node.js 中,文件和模块是一一对应的(每个文件被视为一个独立的模块)。

require进行模块的调用,使用 require.resolve() 函数,加载文件

从 Y 路径的模块 require(X)

  1. 如果 X 是一个核心模块,
    a. 返回核心模块
    b. 结束
  2. 如果 X 是以 '/' 开头
    a. 设 Y 为文件系统根目录
  3. 如果 X 是以 './' 或 '/' 或 '../' 开头
    a. 加载文件(Y + X)
    b. 加载目录(Y + X)
  4. 加载Node模块(X, dirname(Y))
  5. 抛出 "未找到"

加载文件(X)

  1. 如果 X 是一个文件,加载 X 作为 JavaScript 文本。结束
  2. 如果 X.js 是一个文件,加载 X.js 作为 JavaScript 文本。结束
  3. 如果 X.json 是一个文件,解析 X.json 成一个 JavaScript 对象。结束
  4. 如果 X.node 是一个文件,加载 X.node 作为二进制插件。结束

加载索引(X)

  1. 如果 X/index.js 是一个文件,加载 X/index.js 作为 JavaScript 文本。结束
  2. 如果 X/index.json 是一个文件,解析 X/index.json 成一个 JavaScript 对象。结束
  3. 如果 X/index.node 是一个文件,加载 X/index.node 作为二进制插件。结束

加载目录(X)

  1. 如果 X/package.json 是一个文件,
    a. 解析 X/package.json,查找 "main" 字段
    b. let M = X + (json main 字段)
    c. 加载文件(M)
    d. 加载索引(M)
  2. 加载索引(X)

加载Node模块(X, START)

  1. let DIRS=NODE_MODULES_PATHS(START)
  2. for each DIR in DIRS:
    a. 加载文件(DIR/X)
    b. 加载目录(DIR/X)

NODE_MODULES_PATHS(START)

  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
    b. DIR = path join(PARTS[0 .. I] + "node_modules")
    c. DIRS = DIRS + DIR
    d. let I = I - 1
  5. return DIRS

module.exports与exports

module.exports才是模块公开的接口,每个模块都会自动创建一个module对象,对象有一个modules的属性,初始值是个空对象{},module的公开接口就是这个属性——module.exports。既然如此那和exports对象有毛线关系啊!为什么我们也可以通过exports对象来公开接口呢?

为了方便,模块中会有一个exports对象,和module.exports指向同一个变量,所以我们修改exports对象的时候也会修改module.exports对象,这样我们就明白网上盛传的module.exports对象不为空的时候exports对象就自动忽略是怎么回事儿了,因为module.exports通过赋值方式已经和exports对象指向的变量不同了,exports对象怎么改和module.exports对象没关系了。

这个模块导出了两个函数(printA和printB)和一个数字(pi),调用代码看起来像这样:

怎安装nodeJS的外部模块

npm install 模块名
其他参数参考文档比如 -g全局通用等  

增编:软件包管理小贴示
在 Node 中,require() 函数的语义被设计成通用性足以支持大量合理的目录结构。因此 dpkg、rpm 和 npm之类的包管理器可以从 Node 模块构建原生包而不作更改。

function Circle(x, y, r) {

在 `require.paths` 中加入相对路径……不是个好主意

它会产生下面的输出:

  1. If X/package.json is a file,
       a. Parse X/package.json, and look for "main" field.
       b. let M = X + (json main field)
       c. LOAD_AS_FILE(M)
  2. LOAD_AS_FILE(X/index)

复制代码 代码如下:

此外,为了使模块查找过程更加优化,而​​不是直接把包放到 /usr/lib/node 中,我们可以它们放到/usr/lib/node_modules/<name>/<version> 里。这样,Node 就不用在 /usr/node_modules 或/node_modules 中查找了。

在下面的例子里你将会了解到,在Node里文件和模块是一一对应的,我们创建了一个叫circle.js的文件,它仅对外导出了Circle构造函数。

它的值最初从 NODE_PATH 环境变量而来,那是一个冒号分隔的绝对路径列表。在前面的例子中,NODE_PATH 环境变量可能被设置为:

var myModule = require('/home/pedro/my_modules/my_module');

var circle = require('./circle.js');
console.log( 'The area of a circle of radius 4 is '
           + circle.area(4));
circle.js 的内容:

         console.log('Hi!');

/home/ry/projects/foo/node_modules/bar/node_modules/baz/node_modules/asdf.js
/home/ry/projects/foo/node_modules/bar/node_modules/asdf.js
/home/ry/projects/foo/node_modules/asdf.js
以文件夹作为模块
Node 允许用户在独立的目录中方便地组织程序,然后提供单一入口指向该库。有三种方式可以将文件夹作为require() 的参数。

还可以用相对路径或者绝对路径来加载非核心模块,如果把模块放到了node_modules目录下或者对于用NPM安装的模块,你还可以直接使用模块名来加载。

这是 Node 能找到 package.json 文件的情况。

LOAD_AS_DIRECTORY(X)

首先,/node_modules 不会附加到一个以 /node_modules 结尾的文件夹后面。

NODE_MODULES_PATHS(START)

require('./server')  “./”表示当前路径,后面跟的是相对路径
require("../lib/server") ../表示上一级目录,后面跟的也是相对路径

  1. 另DIRS=NODE_MODULES_PATHS(START)

  2. 对DIRS下的每个目录DIR做如下操作:

核心模块在 Node 源代码的 lib/ 文件夹中定义。

加载核心模块

[javascript] 
var http = require('http'); 
function start(){ 
    server = http.createServer(function (req, res) {   
          res.writeHeader(200, {"Content-Type": "text/plain"});   
          res.end("Hello oschinan");   
    })   
    server.listen(8000);   
    console.log("httpd start @8000");  

exports.start = start;  

       }

零隔离

                   }

当嵌套依赖关系的层次很深时,这个文件查找列表可能会变得很长。因此,在查找时进行如下优化:

反之,如果找到了package.json文件,Node会尝试解析它,并查找包定义里的main属性,然后把main属性的值当作入口点的相对路径。以本例来说,如果package.json定义如下:

使用 require() 时,核心模块总是优先加载。例如,require('http') 总是返回内置的 HTTP 模块,即使该名称的文件存在。

module my_module initializing...

比方说,我们希望 /usr/lib/node/<some-package>/<some-version> 文件夹中包含某个包的特定版本的内容。

复制代码 代码如下:

./some-library/index.js
./some-library/index.node
缓存
模块在首次被加载后会缓存起来。这意味着每次调用 require('foo') 将得到完全相同的对象,如果它被解析为同一个文件的话。

function printB() {

如果不以 '/' 或'./' 开头,该模块可以是一个“核心模块”,也可是一个从 node_modules 文件夹中加载的模块。

如果没找到,Node会假设包的入口点是index.js文件(译者注:除了index.js还会查找index.node,.node文件是Node的二进制扩展包,具体见官方文档),以上面代码为例,Node会尝试查找./myModuleDir/index.js文件。

require(http) 内置模块 require(./server) ./表示当前路径,后面跟的是相对路径 require(../lib/server) ../表示上一级目录,后面跟的...

  1. LOAD_NODE_MODULES(X, dirname(Y))

  2. 抛出异常:"not found"

其次,如果调用 require() 的文件已经在一个 node_modules 层级里,那么最顶层的 node_modules 文件夹将被视为搜索树的根。

module.exports.printB = printB;

/usr/lib/node/foo/1.2.3/ -foo 包的内容,版本1.2.3。
/usr/lib/node/bar/4.3.2/ -bar 包的内容,foo 依赖这个包。
/usr/lib/node/foo/1.2.3/node_modules/bar -到 /usr/lib/node/bar/4.3.2/ 的符号链接。
/usr/lib/node/bar/4.3.2/node_modules/* -到 bar 所依赖的包的符号链接。
因此,即使遇到一个回路,或者有依赖冲突,每个模块都能够得到它依赖的可用版本。

每个被当前脚本导入的模块都会向程序员暴露一组公开API,使用模块前,需要用require函数来导入它,像这样:

LOAD_AS_FILE(X)

复制代码 代码如下:

/home/ry/projects/node_modules/bar.js
/home/ry/node_modules/bar.js
/home/node_modules/bar.js
/node_modules/bar.js
这就允许程序将依赖关系本地化,防止它们冲突。

复制代码 代码如下:

从 `node_modules` 文件夹中加载
如果传递给 require() 有模块标识符是不是原生模块,而且不以 '/'、'../' 或'./' 开头,那么 Node 从当前模块的父目录+/node_modules 这个位置尝试加载。

   a. 加载并返回核心模块

为了使 REPL 能够正常引用模块,可以将 /usr/lib/node_modules 添加至 $NODE_PATH环境变量。因为使用node_modules 文件夹查找模块时的路径都是相对的,而且调用 require() 时基于文件的真实路径,因此软件包本身可以放在任何位置。

var myModule2 = require('./lib/my_module_2');

综上所述,这是 require.resolve 的伪码描述:

了解Node如何加载模块

优化 `node_modules` 查找过程

  1. 返回DIRS

如果还是没有找到,那么它跳到上层目录并依此类推,直到找到模块,或者达到根目录为止。

                  function printA() {

总结……
为了得到调用 require() 时被载入的确切的文件名,使用 require.resolve() 函数。

              return Math.pow(r, 2);

 

Node有一些被编译到二进制文件里的模块,被称为核心模块,它们不能通过路径来引用,只能用模块名。核心模块拥有最高的加载优先级,即使已经有了一个同名的第三方模块,核心模块也会被优先加载。

[ '/home/micheil/.node_modules',
  '/usr/local/lib/node_modules' ]
则调用 require('bar/baz.js') 会搜索以下位置:

my_module initialized

Node 有一个简单的模块加载系统。在 Node 中,文件和模块一一对应。比如,在 foo.js 加载同一目录中的circle.js 模块。

   b. 另M = X + (main字段的值)

exports.circumference = function (r) {
  return 2 * PI * r;
};
模块 circle.js 导出了 area() 函数和 circumference() 函数,这样它们就能从模块外部访问了。要导出对象,将其添加到特殊的 exports 对象就行。

不过谢天谢地,Node为服务器端JavaScript定了一些规范,还实现了CommonJS的模块标准,在这个标准里,每个模块有自己的上下文,和其他模块相区分。这意味着,模块不会污染全局作用域,因为根本就没有所谓的全局作用域,模块之间也不会相互干扰。

核心模块
Node 有一些已编译成二进制的模块,这些模块将在本文档的其他地方详细​​介绍。

   b. DIRS = DIRS + DIR

出于兼容性的考虑,require.paths 仍然是模块查找过程的首选策略。尽管如此,它可能会在将来的版本中废弃。

   c. LOAD_AS_FILE(M)

require(X)

  1. 如果X/index.js文件存在,把 X/index.js作为JavaScript 脚本加载,加载完毕后结束

  2. 如果X/index.node文件存在,把load X/index.node作为Node二进制插件加载,加载完毕后结束

exports.area = function (r) {
  return PI * r * r;
};

复制代码 代码如下:

下面我们给出一个可以工作的建议的目录结构:

加载文件模块

{ "name" : "some-library",
  "main" : "./lib/some-library.js" }
如果此文件位于 ./some-library 文件夹,则 require('./some-library') 会尝试加载 ./some-library/lib/some-library.js。

}

1: '/home/micheil/.node_modules/bar/baz.js'
2: '/usr/local/lib/node_modules/bar/baz.js'
可以在运行时修改 require.paths 数组来改变这种行为。

console.log('module my_module initializing...');

结果,如果一个 Node 程序依赖于这种行为,它可能会永久而微妙地改变同一进程中其它 Node 程序的行为。当应用程序的复杂度增加时,我们倾向于封装功能,这些行为很难预料的部分会成为开发者的恶梦。

模块在第一次成功加载后会被缓存起来,就是说,如果模块名被解析到同一个文件路径,那么每次调用require(‘myModule')都确切地会返回同一个模块。

[javascript] 
//路径根据自己的实际情况而定 
var server = require("./learnNode/server"); 
server.start(); 

   b. LOAD_AS_DIRECTORY(Y + X)

.js 文件被视为 JavaScript 文本文件,而 .node 文件被视为已编译的插件模块,用 dlopen 加载。

你也可以导出一些复杂的对象,module.exports被初始化成一个空对象,你把任何你想暴露给外界的内容,作为module.exports对象的属性来导出。比如,你设计了一个模块,它对外暴露了一组函数:

如果你这样做:

非核心模块包括使用NPM(Node Package Manager)安装的第三方模块,以及你或你的同事创建的本地模块。

server.js

也就是说,模块的初始化代码仅执行了一次。当你构建自己的模块时,如果模块的初始化代码里含有可能产生副作用的代码,一定要特别注意这个特性。

这行代码并不会像期望的那样:

一旦Web页面加载了JavaScript代码,它就会被注入到全局命名空间,会和其他所有已加载的脚本公用同一个地址空间,这会导致很多安全问题,冲突,以及一些常见问题,让bug即难以跟踪又很难解决。

require.paths = [ '/usr/lib/node' ];
它的结果就是丢弃了 Node 实际的模块查找路径引用,并创建了一个毫无用处的指向别处的新的引用。

              return Math.PI * r_squared();

模块以 './' 开头表示调用 require() 时使用相对路径。也就是说,为了保证 require('./circle') 能找到,circle.js 必须和 foo.js 在同一目录。

模块有几种不同的类型,大概可以分为核心模块,本地模块和通过NPM安装的第三方模块,根据模块的类型,有几种引用模块的方式,下面我们就来了解下这些知识。

require最常用的方法
require('http') 内置模块

加载模块

/home/micheil/.node_modules:/usr/local/lib/node_modules
只有使用上面的 node_modules 算法找不到模块时才会尝试 require.paths。全局模块的优先级低于捆绑依赖。

};

例如,如果在文件 '/home/ry/projects/foo.js' 中调用 require('bar.js'),那么 Node 将在下列位置查找,顺序如下:

var myModule = require('./myModuleDir');

  1. If X is a file, load X as JavaScript text.  STOP
  2. If X.js is a file, load X.js as JavaScript text.  STOP
  3. If X.node is a file, load X.node as binary addon.  STOP

前面提到过,你可以使用require函数来加载模块,不用担心在代码里调用require会影响全局命名空间,因为Node里就没有全局命名空间这个概念。如果模块存在且没有任何语法或初始化错误,require函数就会返回这个模块对象,你还可以这个对象赋值给任何一个局部变量。

模块的局部变量是私有的。在本例中,变量 PI 是 circle.js 私有的。

var myModule = require('./my_module');

文件模块
如果没有找到确切的文件,Node 将尝试给所需的文件名​​添加 .js 后缀再加载,然后再尝试 .node。

从node_modules目录加载

如果在该目录中没有 package.json 文件,那么 Node 将尝试加载该目录中的 index.js 或 index.node 文件。例如,如果上面的例子找不到 package.json,那么 require('./some-library') 将试图加载:

var myModule = require('../my_modules/my_module');

虽然它看起来似乎是个好主意,但在实践中一个可变的 require.paths 列表往往是麻烦和混乱的根源。

您可能感兴趣的文章:

  • node.js使用require()函数加载模块
  • 浅析node.js的模块加载机制

LOAD_AS_DIRECTORY(X)

   c. DIR = path join(PARTS[0 .. I] + "node_modules")

有一种糟糕的设计:所有模块共用一个 require.paths 数组。

建议读者把官方文档的模块章节阅读一遍,个人感觉比作者讲得更清晰明了,而且还附加了一个非常具有代表性的例子,对理解Node模块加载会很有很大帮助。下面把那个例子也引用过来:

LOAD_NODE_MODULES(X, START)

module my_module initializing...

var PI = Math.PI;

尽管它的开发时间很短,但是JavaScript依然具备了很多强大的特性,不过,每个脚本共享一个全局命名空间这个特性除外。

下面介绍require的只是来自于链接:

   c. 另I = I - 1

在实践中,人们往往将它作为捆绑依赖的临时解决办法,这个技巧是不太稳妥的。

       }

**注意** 请不要修改 `require.paths`

上面的代码会导入一个名为module_name的模块,它可能是个核心模块,也可以是用NPM安装的模块,require函数返回一个包含模块所有公共API的对象。随模块的不同,返回的对象可能是任何JavaScript值,可以是一个函数,也可以是个包含了一系列属性(函数,数组或者任何JavaScript对象)的对象。

foo.js 的内容:

var myModule = require('myModule.js');

  1. let PARTS = path split(START)
  2. let ROOT = index of first instance of "node_modules" in PARTS, or 0
  3. let I = count of PARTS - 1
  4. let DIRS = []
  5. while I > ROOT,
       a. if PARTS[I] = "node_modules" CONTINUE
       c. DIR = path join(PARTS[0 .. I] + "node_modules")
       b. DIRS = DIRS + DIR
  6. return DIRS
    从 `require.paths` 加载
    在 Node 中,require.paths 是一个字符串数组,表示模块不以 '/' './' 或 '..' 打头的搜索路径。例如,如果 require.paths 设置为:

你可以使用这个特性来管理node_modules目录的内容或模块,不过最好还是把模块的管理任务交给NPM(见第一章),本地node_modules目录是NPM安装模块的默认位置,这个设计把Node和NPM关联在了一起。通常,作为开发人员不必太关心这个特性,你可以简单的使用NPM安装,更新和删除包,它会帮你维护node_modules目录

模块以 '/' 开头表示使用文件的绝对路径。例如,require('/home/marco/foo.js') 将加载/home/marco/foo.js 文件。

复制代码 代码如下:

  1. let DIRS=NODE_MODULES_PATHS(START)
  2. for each DIR in DIRS:
       a. LOAD_AS_FILE(DIR/X)
       b. LOAD_AS_DIRECTORY(DIR/X)

module.exports = function() {

NODE_MODULES_PATHS(START)

注意上面的代码,你可以省略文件名的扩展名,如果Node找不到这个文件,会尝试在文件名后加上js后缀再次查找(译者注:其实除了js,还会查找json和node,具体可以看官网文档),因此,如果在当前目录下存在一个叫my_module.js的文件,会有下面两种加载方式:

require.paths.push('./lib');
它不会添加 ./lib 在文件系统上已解析的完整路径。相反,它实际增加的是 './lib',这意味着如果你在/a/b/x.js 中 require('y.js'),那么它会查找 /a/b/lib/y.js。如果你之后又在 /l/m/n/o/p.js 中require('y.js'),那么它就会查找 /l/m/n/o/lib/y.js。

module.exports = Circle;

  1. If X is a core module,
       a. return the core module
       b. STOP
  2. If X begins with `./` or `/`,
       a. LOAD_AS_FILE(Y + X)
       b. LOAD_AS_DIRECTORY(Y + X)
  3. LOAD_NODE_MODULES(X, dirname(Y))
  4. THROW "not found"

CommonJS模块系统是Node下文件间共享对象和函数的唯一方式。对于一个很复杂的程序,你应该把一些类,对象或者函数重构成一系列良好定义的可重用模块。对于模块使用者来说,模块仅对外暴露出那些你指定的代码。

例如,如果在文件 '/home/ry/projects/foo/node_modules/bar/node_modules/baz/quux.js' 中调用require('asdf.js'),那么 Node 将搜索下列位置:

小结

一个软件包可以依赖别的包。为了安装 foo 包,你可能需要安装 bar 包的特定版本 。可能该 bar 包本身有依赖关系,在某些情况下,这些依赖关系甚至可能发生冲突或者形成回路。

本章,我们将了解几种不同的模块以及如何加载它们。

模块
Node 使用 CommonJS 模块系统。

  1. 如果X以 './' or '/' or '../ 开始'

第一种方式是在该文件夹中创建 package.json 文件,指定一个 main 模块。一个典型的 package.json 文件可能看起来像这样:

                            "main" : "./lib/myModule.js"

修改 `require.paths` 毫无用处

复制代码 代码如下:

由于 Node 在加载任何模块时都会查找它的真实路径(即:会解析符号链接),然后在 node_modules 文件夹用上文描述的方式查找依赖。使用以下架构可以很简单地解决:

复制代码 代码如下:

把代码拆分成一系列定义良好的模块可以帮你掌控你的应用程序,下面我们将学习如何创建和使用你自己的模块。

复制代码 代码如下:

复制代码 代码如下:

复制代码 代码如下:

         console.log('C');

                   {

   a. LOAD_AS_FILE(Y + X)

function printC() {

var myModule = require('./my_module.js');

复制代码 代码如下:

       function area() {

输出依然是:

你也可以使用绝对路径从文件系统里加载模块:

缓存模块

       function r_squared() {

my_module initialized

   a. LOAD_AS_FILE(DIR/X)

         console.log('A');

如果require函数的参数不是相对路径,也不是核心模块名,Node会在当前目录的node_modules子目录下查找,比如下面的代码,Node会尝试查找文件./node_modules/myModule.js:

   a. 如果 PARTS[I] = "node_modules" 则继续后续操作,否则下次循环

LOAD_NODE_MODULES(X, START)

       return {area: area};

复制代码 代码如下:

         var http = require('http');

console.log('my_module initialized.');

console.log(myModule2.pi); // -> 3.141592653589793

var myModuleInstance1 = require('./my_module');

代码里最重要的是最后一行,它定义了模块对外导出了什么内容。module是个特殊的变量,它代表当前模块自身,而module.exports是模块对外导出的对象,它可以是任何对象,在这个例子里,我们把Circle的构造函数导出了,这样模块使用者就可以用这个模块来创建Circle实例。

Node会假定这个目录是个模块包,并尝试在这个目录下搜索包定义文件package.json。

LOAD_AS_FILE(X)

  1. 另PARTS = path split(START)

  2. 另ROOT = index of first instance of "node_modules" in PARTS, or 0

  3. 另I = count of PARTS - 1

  4. 另DIRS = []

  5. while I > ROOT,

   b. 结束

   b. LOAD_AS_DIRECTORY(DIR/X)

然后用下面的代码加载这个模块:

复制代码 代码如下:

复制代码 代码如下:

   a. 解析X/package.json, 并查找 "main"字段.

var myModule2 = require('./myModule2');

         console.log('B');

比如,有一个叫my_module.js的模块,包含下面的内容:

复制代码 代码如下:

用require(X) 加载路径Y下的模块

Node里,可以通过文件路径来引用模块,也可以通过模块名引用,如果用名称引用非核心模块,Node最终会把模块名影射到对应的模块文件路径。而那些包含了核心函数的核心模块,会在Node启动时被预先加载。

var module = require(‘module_name')

  1. 如果X是核心模块,

也可以用一个基于当前文件的相对路径:

Node就会尝试加载./myModuleDir/lib/myModule.js文件

你还可以使用目录的路径来加载模块:

module.exports.pi = Math.PI;

  1. 如果X是个文件,把 X作为JavaScript 脚本加载,加载完毕后结束

  2. 如果X.js是个文件,把X.js 作为JavaScript 脚本加载,加载完毕后结束

  3. 如果X.node是个文件,把X.node 作为Node二进制插件加载,加载完毕后结束

比如,如果你想加载和使用http核心模块,可以这样做:

                            "name" : "myModule",

var myModuleInstance2 = require('./my_module');

 译者注:

如果没找到,Node会继续在上级目录的node_modules文件夹下查找,如果还没找到就继续向上层目录查找,直到找到对应的模块或者到达根目录。

Node取消了JavaScript的默认全局作用域,转而采用CommonJS模块系统,这样你可以更好的组织你的代码,也因此避免了很多安全问题和bug。可以使用require函数来加载核心模块,第三方模块,或从文件及目录加载你自己的模块

myModule2.printA(); // -> A

复制代码 代码如下:

这将返回一个包含了http模块对象,它包含了Node API文档里定义的那些htpp模块的API。

var myModuleInstance1 = require('./my_module');

module.exports.printA = printA;

}

}

myModule2.printB(); // -> B

  1. 如果 X/package.json文件存在,

}

导出模块

加载目录模块

本文由美高梅网址发布于新闻中心,转载请注明出处:js零起点开发,js模块机制

上一篇:已经计划系统关机,JS关闭窗口与JS关闭页面的几 下一篇:没有了
猜你喜欢
热门排行
精彩图文