Node.js学习笔记----day03

认真学习，认真记录，每天都要有进步呀！！！

加油叭！！！

一、Node中的模块系统

使用Node编写应用程序主要就是在使用

EcmaScript

和浏览器不一样的是，在Node中没有BOM、DOM

核心模块

文件操作的fs
http服务的http
url路径操作模块
os操作系统信息

第三方模块

art-template
必须通过npm来下载才可以使用

自己创建的模块

自己创建的文件

二、什么是模块化

具有文件作用域（没有污染）
具有通信规则（即可以加载又可以导出）

三、CommonJS模块化

在Node中的JavaScript还有一个很重要的概念：模块系统

模块作用域

与浏览器相比不是全局作用域，模块作用域，默认全局当中的所有成员不能被外部访问
使用 require() 方法来加载模块

没有 script 标签，不能通过 script 标签来加载文件
使用 exports 接口对象来导出模块中的成员

四、加载与导出

加载require()

语法：

var 自定义变量名称 = require('模块')

require 方法有两个作用：

（1）加载文件模块并执行里面的代码

（2）得到被加载文件模块导出的接口对象

导出exports()

Node中是模块作用域，默认文件中所有的成员只在当前文件模块有效

对于希望可以被其他模块访问的成员，我们就需要把这些公开的成员都挂载到exports接口中就可以了

在每个文件模块中都提供了一个对象：exports

exports 默认是一个空对象

你要做的就是把所有需要被外部访问的成员挂载到这个 exports 对象中

2.1 导出多个成员

exports.age = 123

exports.hi= 'hello'

exports.func = function(){

console.log('aaa')

}

exports.message={

name:'zs'

}

也可以这样来导出多个成员

module.exports = {

add = function(){

return x + y

},

str:'hello'

}

2.2 导出单个成员，拿到的就是函数，字符串

module.exports = 'hello'

以下情况会覆盖

module.exports = 'hello'

//以这个为准，后者会覆盖前者

module.exports = function(x,y){

return x + y

}

五、exports与module.exports的原理解析

在 Node 中，每个模块内部都有一个自己的 module 对象

该 module 对象中，有一个成员叫：exports

 var module = {

   exports: {

   对象名：'对象内容',

   方法名:function

   }

 }

  //模块中还有一句

 var exports = module exports

 //默认在代码最后一句

 //谁来require我，谁就得到module exports

 return module exports

也就是说如果你需要对外导出成员，只需要把导出的成员挂载到 module.exports 中

main.js

var fooExports = require('./foo')

console.log(fooExports)

foo.js

 module.exports.test1 = 'hello'

 module.exports.test2 = 'world'

 module.exports.add = function (x, y) {

   return x + y

 }

 module.exports.reduce = function (x, y) {

   return x - y

 }

foo.js相当于

 var module = {

  exports: {

   test1: 'hello',

   test2: 'world',

  add: function,

  reduce:function,

  }

}

执行main.js结果：

再添加一些exports对象与方法

foo.js

 module.exports.test1 = 'hello'

 module.exports.test2 = 'world'

  exports.test3 = 'hi'

  exports.test4 = 'node.js'

 module.exports.add = function (x, y) {

   return x + y

 }

 module.exports.reduce = function (x, y) {

   return x - y

 }

 exports.a = function(a,b){

 	return a + b

 }

 exports.b = function(a,b){

 	return a + b

 }

结果：

我们发现，exports == module.exports，两者一致，说明可以使用任意一方来导出接口成员

每次导出接口成员的时候都通过 module.exports.xxx = xxx 的方式很麻烦，点儿的太多了

所以，Node 为了简化操作，专门提供了一个变量：exports 等于 module.exports

exports相当于 module.exports的一个引用

console.log(exports == module.exports)  // true

exports.foo = 'bar'

//等价于

module.exports.foo = 'bar'

也就是说在模块中还有这么一句代码

var exports = module.exports

当一个模块需要导出单个成员的时候

直接给 exports 赋值是不管用的

栗子：



exports = 'hello'

是个空对象，什么都没有

一定要记住，最后 return 的是 module.exports

不是 exports

所以你给 exports 重新赋值不管用，

return module.exports

对比去理解的栗子：

没有给exports 重新赋值之前

栗子：

 exports.a = 123

 // exports = {}

 exports.foo = 'bar'

给exports 重新赋值后

栗子：

 exports.a = 123

 exports = {}

 exports.foo = 'bar'

给 exports 赋值会断开和 module.exports 之间的引用，重新赋值以后，跟原来没有关系，后面添加都不管用

exports的修改不影响module.export

栗子：

exports.a = 123

exports = {}

exports.foo = 'bar'

module.exports.b = 456

//module.export一直都没有变，所有可以导出 b:456

//exports的修改不影响module.export

module.exports 重新赋值会断开与exports的引用

栗子：

module.exports = 'hello'

exports.a = '123'

总结：

给 exports 赋值会断开和 module.exports 之间的引用

同理，给 module.exports 重新赋值也会断开

栗子：

// 这里导致 exports !== module.exports

 module.exports = {

  foo: 'bar'

 }

// // 但是这里又重新建立两者的引用关系

 exports = module.exports

 exports.foo = 'hello'

结果：

栗子：

 //{foo: bar}

exports.foo = 'bar'

 // {foo: bar, a: 123}

module.exports.a = 123

// exports !== module.exports

// 最终 return 的是 module.exports

// 所以无论你 exports 中的成员是什么都没用

 exports = {

   a: 456

 }

// {foo: 'haha', a: 123}

 module.exports.foo = 'haha'

 // 没关系，混淆你的

 exports.c = 456

 // 重新建立了和 module.exports 之间的引用关系了

 exports = module.exports

 // 由于在上面建立了引用关系，所以这里是生效的

 // {foo: 'haha', a: 789}

 exports.a = 789

最终结果：

再加上一句：

// // 前面再牛逼，在这里都全部推翻了，重新赋值

// // 最终得到的是 Function

 module.exports = function () {

  console.log('hello')

 }

结果：

归纳总结：

真正去使用的时候：

导出多个成员：exports.xxx = xxx

导出多个成员也可以：module.exports = { }

导出单个成员：module.exports

六、总结exports与module.exports的区别

每个模块中都有一个 module 对象
module 对象中有一个 exports 对象
我们可以把需要导出的成员都挂载到 module.exports 接口对象中
也就是：moudle.exports.xxx = xxx 的方式
但是每次都 moudle.exports.xxx = xxx 很麻烦，点儿的太多了
所以 Node 为了你方便，同时在每一个模块中都提供了一个成员叫：exports
exports === module.exports 结果为 trues
所以对于：moudle.exports.xxx = xxx 的方式完全可以：expots.xxx = xxx
当一个模块需要导出单个成员的时候，这个时候必须使用：module.exports = xxx 的方式
不要使用 exports = xxx 不管用
因为每个模块最终向外 return 的是 module.exports
而 exports 只是 module.exports 的一个引用
所以即便你为 exports = xx 重新赋值，也不会影响 module.exports
但是有一种赋值方式比较特殊：exports = module.exports 这个用来重新建立引用关系的

七、require方法加载规则

优先从缓存加载

结果:

判断模块标识

核心模块

核心模块的本质也是文件

核心模块文件已经被编译到了二进制文件中了，我们只需要按照名字来加载就可以了

eg:

require('fs')

require('http')

路径形式的文件模块(自定义模块)

路径形式的模块：

./ 当前目录，不可省略

../ 上一级目录，不可省略

/xxx 几乎不用

d:/a/foo.js 几乎不用

首位的 / 在这里表示的是当前文件模块所属磁盘根路径

.js 后缀名可以省略

require('./foo') 相当于 require('./foo.js')

第三方模块

凡是第三方模块都必须通过 npm 来下载

使用的时候就可以通过 require('包名') 的方式来进行加载才可以使用

不可能有任何一个第三方包和核心模块的名字是一样的

第三方模块既不是核心模块、也不是路径形式的模块

先找到当前文件所处目录中的node_modules目录

node_modules/art-template

node_modules/art-template/package.json文件

node_modules/art-template/package.json 文件中的 main 属性

main 属性中就记录了 art-template 的入口模块

然后加载使用这个第三方包

实际上最终加载的还是文件

如果 package.json 文件不存在或者 main 指定的入口模块是也没有

则 node 会自动找该目录下的 index.js

也就是说 index.js 会作为一个默认备选项

如果以上所有任何一个条件都不成立，则会进入上一级目录中的 node_modules 目录查找

如果上一级还没有，则继续往上上一级查找

。。。

如果直到当前磁盘根目录还找不到，最后报错：

can not find module xxx

var template = require('art-template')

注意：我们一个项目有且只有一个 node_modules，放在项目根目录中，这样的话项目中所有的子目录中的代码都可以加载到第三方包

不会出现有多个 node_modules

总结模块查找机制

优先从缓存加载

核心模块

路径形式的文件模块

第三方模块

node_modules/art-template/

node_modules/art-template/package.json

node_modules/art-template/package.json main

index.js 备选项

进入上一级目录找 node_modules

按照这个规则依次往上找，直到磁盘根目录还找不到，最后报错：Can not find moudle xxx

一个项目有且仅有一个 node_modules 而且是存放到项目的根目录

参考详细文档: 深入Node.js的模块机制

八、npm

node package manager

npm 网站 : https://www.npmjs.com/

可以用来搜索第三方包
npm命令行工具

npm的第二层含义就是命令行工具,只要你安装了node 就相当于安装了npm

npm 也有版本的这个概念

查看npm版本

npm --version

升级npm版本

npm install --global npm

npm 常用命令

详细参考文档：https://www.cnblogs.com/PeunZhang/p/5553574.html
解决npm被墙的问题

参考文档：https://blog.csdn.net/qq_45103612/article/details/108569090

九、package.json

建议每一个项目都要有一个package.json (包描述文件,就像产品说明书一样)

这个文件可以通过npm init的方式初始化出来

建议每个项目的根目录中都有一个package.json文件
建议执行npm install 包名的时候都加上 --save这个选项,目的是用来保存依赖项信息
可以在package.json文件中通过dependencies选项,查看第三方包的依赖信息
如果项目中的node_modules项目丢失了,只要 package.json文件存在,我们只需要npm install,就会自动把package.json中的dependencies中的所有依赖项都下载回来

十、package.json与package-lock.json

npm5以前是不会有package.json这个文件的

npm5以后才加入了这个文件

当你安装包以后，npm都会自动安装package-lock.json这个文件

npm5以后的版本安装包不需要加上--save参数，它会自动保存依赖信息
当你安装包的时候，会自动创建或更新package-lock.json这个文件
package-lock.json会保存node_modules中所有包的信息（版本，下载地址）
这样的话重新npm install的速度就会提升很多
从文件来看，有一个lock称之为锁
这个lock是用来锁定版本的
如果这个项目依赖了1.1.1版本
如果你npm install其实会下载最新版，而不是1.1.1
所以package-loca.json的另外一个作用就是锁定版本号，防止自动升级新版