02_模块化-学习笔记

2026 年 4 月 24 日

4035 字

13 分钟

Node.js

模块化 · Node.js 学习笔记

基于 02_模块化.pdf 整理
适合作为 Node.js 模块化、npm 与模块加载机制的入门笔记。


1. 课程结构总览

这份 PDF 主要分成四部分:

  1. 模块化的基本概念
  2. Node.js 中的模块化
  3. npm 与包
  4. 模块的加载机制

如果说 day1 讲的是“Node.js 能做什么”,那么这份 day2 讲的就是:

Node.js 项目中的代码和依赖,应该如何被拆分、共享、安装和加载。


2. 模块化的基本概念

2.1 什么是模块化

模块化的本质是:

在解决复杂问题时,把系统自顶向下拆分成多个小模块,每个模块都承担独立职责。

对于整个系统来说,模块应该具备这些特点:

  • 可组合
  • 可拆分
  • 可替换

2.2 编程中的模块化

在编程领域,模块化通常指:

  • 遵守统一规则
  • 把一个大文件拆成多个独立小模块
  • 模块之间可以互相依赖

模块化的好处:

  1. 提高复用性
  2. 提高可维护性
  3. 支持按需加载

一句话理解:

大项目不是一口气写成的,而是由很多职责单一的小模块组合起来的。

2.3 什么是模块化规范

模块化规范,就是模块拆分与组合时要遵守的一套规则。

例如:

  • 用什么语法导入模块
  • 用什么语法导出成员
  • 模块之间如何依赖

它的意义是:

  • 统一团队写法
  • 降低沟通成本
  • 方便模块互相调用

3. Node.js 中的模块化

3.1 Node.js 中模块的分类

根据来源不同,Node.js 中的模块分为三类:

1)内置模块

由 Node.js 官方提供,例如:

  • fs
  • path
  • http

2)自定义模块

用户自己创建的 .js 文件。

例如:

// utils.js
function add(a, b) {
  return a + b
}

3)第三方模块

由第三方开发并发布的模块,不属于 Node.js 官方,也不是你自己写的,需要先安装再使用。

例如:

  • moment
  • express
  • lodash

4. 加载模块:require()

4.1 基本作用

Node.js 使用 require() 来加载模块。

它可以加载:

  • 内置模块
  • 自定义模块
  • 第三方模块

例如:

const fs = require('fs')
const path = require('path')
const custom = require('./custom.js')

4.2 一个重要现象

课程特别提醒:

使用 require() 加载模块时,会执行被加载模块中的代码。

例如:

// a.js
console.log('a 模块被执行了')
require('./a.js')

运行时就会输出:

a 模块被执行了

这说明:

  • require() 不只是“拿到一个对象”
  • 它还会触发模块初始化执行

5. 模块作用域

5.1 什么是模块作用域

在自定义模块中定义的变量、方法等成员,只能在当前模块内部访问。

这种“模块级别的访问限制”就叫:

模块作用域

例如:

// test.js
const username = 'zs'

function sayHi() {
  console.log('hello')
}

外部文件不能直接访问 username 和 sayHi(),除非它们被显式导出。

5.2 模块作用域的好处

最大的作用是:

防止全局变量污染。

也就是说:

  • 不同模块内部可以安心写自己的变量
  • 不会轻易污染全局命名空间

6. 向外共享模块成员

6.1 module 对象

在每个 .js 自定义模块中,Node.js 都提供了一个 module 对象。

这个对象里面保存了与当前模块相关的信息。

6.2 module.exports

如果希望把模块内部的成员共享出去给其他文件用,可以使用:

module.exports

外界通过 require() 拿到的,实际上就是:

module.exports 指向的对象

示例:

// utils.js
const username = 'zs'

function sayHi() {
  console.log('Hello!')
}

module.exports.username = username
module.exports.sayHi = sayHi
// app.js
const m = require('./utils')
console.log(m)

6.3 一个关键结论

课程强调:

require() 导入模块时,得到的结果永远以 module.exports 指向的对象为准。

这句话非常重要,因为它决定了“最终导出结果到底是谁”。


7. exports 对象

7.1 为什么有 exports

因为 module.exports 写起来比较长,Node.js 又提供了一个更简短的对象:

exports

默认情况下:

exports === module.exports

它们一开始指向同一个对象。

7.2 常见写法

exports.username = 'zs'
exports.sayHi = function () {
  console.log('Hello!')
}

7.3 使用误区

最终共享结果,仍然以 module.exports 为准。

也就是说:

  • 往 exports.xxx 上挂属性,本质上等于往 module.exports.xxx 上挂属性
  • 但如果你直接重写了 exports = {},不会真正改变最终导出结果

例如:

exports = {
  username: 'zs'
}

这样通常不会达到预期。

7.4 最佳实践

课程建议:

不要在同一个模块里同时混用 exports 和 module.exports。

实战建议:

  • 简单追加成员,用 exports.xxx = ...
  • 想整体导出一个新对象,直接写 module.exports = {...}

8. Node.js 中的模块化规范:CommonJS

Node.js 遵循的是:

CommonJS 模块化规范

CommonJS 的核心约定:

  1. 每个模块内部都有一个 module 对象
  2. module.exports 是对外接口
  3. require() 用来加载模块
  4. 加载某个模块,本质上就是加载它的 module.exports

你可以把它总结成一句话:

导出靠 module.exports,导入靠 require()。


9. npm 与包

9.1 什么是包

在 Node.js 里:

第三方模块 = 包(package)

也就是说,“第三方模块”和“包”其实是一个东西,只是叫法不同。

9.2 包从哪里来

包由第三方开发者或团队编写,并上传到 npm 平台供大家使用。

两个常见地址:

  • 搜索包的网站:https://www.npmjs.com/
  • 下载包的服务地址:https://registry.npmjs.org/

9.3 为什么需要包

因为 Node.js 内置模块提供的更多是底层能力。

而包通常是在这些底层能力基础上的进一步封装,提供:

  • 更高级的 API
  • 更方便的调用方式
  • 更高的开发效率

课程举的类比很形象:

包和内置模块的关系,有点像 jQuery 和浏览器原生 API 的关系。


10. npm 是什么

npm 全称:

Node Package Manager

它是 Node.js 自带的包管理工具,用于:

  • 下载包
  • 安装包
  • 卸载包
  • 管理包的版本和依赖

查看版本:

npm -v

11. npm 初体验

11.1 传统做法 vs 包的做法

课程中用“格式化时间”举了例子。

传统做法

自己写一个时间格式化模块,需要:

  • 自己封装函数
  • 自己写补零逻辑
  • 自己导出
  • 自己导入

更高效的做法

直接安装成熟的第三方包,例如:

  • moment

然后通过 require() 导入,调用官方 API 完成格式化。

这正体现了包的价值:

少重复造轮子。


12. 安装包

12.1 安装指定包

npm install 包名

简写:

npm i 包名

例如:

npm install moment
npm i moment

12.2 安装指定版本

npm install 包名@版本号

例如:

npm i moment@2.29.1

13. 初次安装包后会出现什么文件

第一次安装包后,项目里通常会多出两个内容:

13.1 node_modules

用来存放所有安装到项目中的包。

当你:

require('moment')

Node.js 就会去 node_modules 中查找这个包。

13.2 package-lock.json

记录安装依赖的详细信息,例如:

  • 包名
  • 版本号
  • 下载地址
  • 依赖关系

13.3 注意事项

课程强调:

  • 不要手动修改 node_modules
  • 不要手动修改 package-lock.json

它们应该交给 npm 自动维护。


14. 语义化版本规范

包的版本号通常是三位数字:

x.y.z

例如:

2.24.0

它们分别表示:

  • 第 1 位:大版本
  • 第 2 位:功能版本
  • 第 3 位:Bug 修复版本

升级规则:

  • 前一位增长时,后一位归零

例如:

  • 1.2.3 -> 1.3.0
  • 1.2.3 -> 2.0.0

15. package.json 包管理配置文件

15.1 为什么需要它

当项目安装了很多包之后,node_modules 会非常大。

课程里的例子说明:

  • 项目源码很小
  • 第三方包却很大

多人协作时,如果直接把整个 node_modules 传来传去,会很低效。

因此需要一个文件,记录:

  • 项目名称
  • 版本
  • 描述
  • 依赖列表
  • 开发依赖列表

这个文件就是:

package.json

15.2 如何快速创建

npm init -y

课程提醒:

  • 项目目录最好使用英文名
  • 不要有空格
  • 安装包时,npm 会自动把依赖信息写进 package.json

15.3 dependencies

dependencies 用来记录:

项目运行时也需要的依赖

例如:

{
  "dependencies": {
    "moment": "^2.29.1"
  }
}

15.4 devDependencies

devDependencies 用来记录:

只在开发阶段使用、上线后不需要的依赖

比如:

  • 构建工具
  • 代码检查工具
  • 测试工具

安装到开发依赖中通常用:

npm install 包名 -D

或:

npm i 包名 --save-dev

15.5 一次性安装所有依赖

当别人给你一个没有 node_modules 的项目时,只要有 package.json,就可以直接执行:

npm install

或:

npm i

npm 会自动把所有依赖装回来。

15.6 卸载包

npm uninstall 包名

特点:

  • 会删除包本身
  • 也会自动把它从 dependencies 中移除

15.7 团队协作建议

课程特别提醒:

node_modules 一定要加入 .gitignore

因为:

  • 体积大
  • 可重复安装
  • 没必要进入版本库

16. 下包速度慢与镜像源

16.1 为什么慢

npm 默认从国外官方源下载包:

  • https://registry.npmjs.org/

由于网络链路问题,速度可能比较慢。

16.2 淘宝 npm 镜像

课程中介绍了淘宝镜像服务器,它会同步 npm 官方源的数据,在国内提供更快的下载速度。

16.3 镜像源切换工具 nrm

为了方便切换镜像源,可以安装:

  • nrm

它可以帮助你:

  • 查看当前镜像源
  • 快速切换镜像源

17. 包的分类

使用 npm 下载的包,分成两类:

17.1 项目包

安装到当前项目的 node_modules 中。

又分两类:

开发依赖包

记录在:

  • devDependencies

只在开发阶段使用。

核心依赖包

记录在:

  • dependencies

开发和上线后都需要。

17.2 全局包

如果安装时使用 -g:

npm install 包名 -g

就会安装为全局包。

全局包的特点:

  • 一般用于命令行工具
  • 重点是提供终端命令
  • 不是所有包都适合全局安装

课程强调:

只有工具性质的包,才更适合全局安装。


18. 规范的包结构

一个规范的包,至少要满足这三个条件:

  1. 包必须以单独目录存在
  2. 顶级目录下必须有 package.json
  3. package.json 中至少要有:
    • name
    • version
    • main

它们分别表示:

  • 包名
  • 版本号
  • 入口文件

这说明一个包不是“随便几个 js 文件”,而是一个有规范入口和配置的完整单元。


19. 开发自己的包

课程里设计了一个练习包,需要实现三个功能:

  1. 格式化日期
  2. 转义 HTML 特殊字符
  3. 还原 HTML 特殊字符

19.1 初始化包结构

例如创建:

  • package.json
  • index.js
  • README.md

19.2 再做模块拆分

课程建议把不同功能拆到 src/ 中,例如:

  • src/dateFormat.js
  • src/htmlEscape.js

然后在入口 index.js 中统一导入并导出。

这种做法体现的思想很重要:

包本身也应该模块化。

19.3 README.md 的作用

README 是包的使用说明书。

一个合格的 README 通常至少说明:

  • 安装方式
  • 导入方式
  • API 用法
  • 示例
  • 注意事项
  • 开源协议

20. 发布包到 npm

20.1 注册 npm 账号

流程大致是:

  1. 去 npm 官网注册账号
  2. 填写用户名、邮箱、密码
  3. 邮箱验证

20.2 登录 npm

npm login

课程特别提醒:

发布包前,必须切换到 npm 官方源,否则可能发布失败。

20.3 发布包

进入包根目录后执行:

npm publish

注意:

  • 包名不能和已有包重复

20.4 删除已发布的包

npm unpublish 包名 --force

但有很多限制:

  • 只能删除 72 小时内发布的包
  • 删除后 24 小时内不能重复发布同名包

课程给出的态度也很明确:

发布包要慎重,不要随便往 npm 上发布没有意义的包。


21. 模块的加载机制

这是这份 PDF 最容易出面试题的部分。

21.1 优先从缓存中加载

模块第一次加载后会被缓存。

这意味着:

  • 多次 require() 同一个模块
  • 不会导致模块代码被重复执行

这个机制适用于:

  • 内置模块
  • 自定义模块
  • 第三方模块

作用是:

提高模块加载效率。


22. 内置模块的加载机制

内置模块加载优先级最高。

例如:

require('fs')

永远优先得到 Node.js 自带的 fs 模块。

即使你本地某个地方有一个同名第三方包,也不会抢过内置模块。


23. 自定义模块的加载机制

23.1 必须写相对路径标识符

加载自定义模块时,必须加:

  • ./
  • ../

例如:

require('./utils')

如果不写,Node.js 会把它当成:

  • 内置模块
  • 或第三方模块

去查找。

23.2 省略扩展名时的查找顺序

如果省略扩展名,Node.js 会按顺序尝试:

  1. 按原文件名找
  2. 补 .js
  3. 补 .json
  4. 补 .node
  5. 全部失败则报错

这点很实用,因为很多时候我们写:

require('./utils')

实际上 Node.js 可能最终加载的是:

./utils.js

24. 第三方模块的加载机制

如果 require() 里的标识符:

  • 不是内置模块
  • 也不以 ./ 或 ../ 开头

那么 Node.js 会把它当成第三方模块来查找。

查找规则是:

  1. 先在当前文件所在目录下找 node_modules
  2. 找不到就往上一级目录找
  3. 一层层向父级目录回溯
  4. 直到文件系统根目录
  5. 还找不到就报错

这个机制解释了为什么:

  • 你在项目根装的包
  • 子目录文件通常也能直接 require() 到

25. 目录作为模块时的加载规则

当 require() 传入的是一个目录时,Node.js 会按这个顺序尝试:

  1. 找目录下的 package.json
  2. 读取其中的 main 字段作为入口
  3. 如果没有 package.json,或 main 无法解析,则尝试 index.js
  4. 还不行就报错

也就是说,一个目录能否被 require(),关键看:

  • 有没有合法入口
  • main 是否正确
  • 或是否存在默认的 index.js

26. 本节课核心知识清单

如果只看这份 PDF,最少要掌握这些内容:

模块化基础

  • 什么是模块化
  • 模块化的好处
  • 什么是模块化规范

Node.js 模块化

  • 模块分三类:内置、自定义、第三方
  • require() 会执行模块代码
  • 理解模块作用域
  • 会使用 module.exports
  • 知道 exports 和 module.exports 的关系
  • 知道 Node.js 用的是 CommonJS

npm 与包

  • 包就是第三方模块
  • 会安装 / 卸载包
  • 会使用 package.json
  • 能区分 dependencies 和 devDependencies
  • 知道项目包和全局包的区别
  • 知道语义化版本号

加载机制

  • 模块会被缓存
  • 内置模块优先级最高
  • 自定义模块要写相对路径
  • 第三方模块从 node_modules 向上查找
  • 目录模块会找 package.json 的 main 或 index.js

27. 一页速查表

27.1 导出模块

module.exports = {
  username: 'zs',
  sayHi() {
    console.log('Hello')
  }
}

27.2 导入模块

const m = require('./utils')

27.3 安装包

npm install 包名
npm i 包名

27.4 安装指定版本

npm i 包名@版本号

27.5 安装开发依赖

npm i 包名 -D

27.6 卸载包

npm uninstall 包名

27.7 初始化 package.json

npm init -y

27.8 一次性安装所有依赖

npm install

28. 学完这节课后的建议

建议你按这个顺序自己练一遍:

  1. 手写两个自定义模块,并用 require() 导入
  2. 分别练习 module.exports 和 exports
  3. 创建一个项目,执行 npm init -y
  4. 安装一个第三方包,再卸载掉
  5. 手动观察 package.json、package-lock.json、node_modules
  6. 自己写一个小工具包,体验模块拆分和统一导出

这样你会真正理解“模块化”不是背概念,而是组织代码和管理依赖的方式。


29. 一句话总结

这份 PDF 的核心,可以总结成一句话:

模块化解决的是代码如何拆分与共享,npm 解决的是依赖如何安装与管理,加载机制决定了 Node.js 到底会把哪个模块加载进来。

02_模块化-学习笔记
https://blog.yagami.top/blog/nodejs/day2/02_模块化-学习笔记/
作者
Nekode
发布时间
2026 年 4 月 24 日
许可协议
CC BY-NC-SA 4.0

正在加载评论...

目录

输入关键词开始搜索