Node 服务端学习笔记

适合目标：系统掌握 Node.js 服务端开发能力，覆盖 Node 基础、核心模块、Web 框架、数据库、鉴权、安全、测试、部署与高频面试题。
学习定位：这一份偏“会写服务、会看原理、会做项目、会答面试”。
学习原则：先理解 Node 运行时，再理解服务端架构；先会写小接口，再学框架和工程化；先把主线串起来，再补细节。

---

目录

1. 学习总览
2. Node 到底是什么
3. Node 基础环境与工程入口
4. Node 核心运行机制
5. 核心模块
6. 异步编程与事件循环
7. Buffer、Stream 与文件处理
8. HTTP 服务与接口开发
9. 常见服务端框架
10. 数据库与缓存
11. 鉴权、安全与权限控制
12. 日志、调试、测试与监控
13. 部署与上线
14. 高频面试题
15. 8 小时学习规划
16. 一页速记总结
17. 背诵口诀

---

1. 学习总览

1.1 学 Node 服务到底在学什么

很多人学 Node 会有一个误区：

1. 以为 Node 就是“在后端写 JS”
2. 以为会用 Express 就等于会做服务端
3. 以为服务端只要会 CRUD 就够了

其实 Node 服务学习要建立三层认知：

1. Node 运行时层：事件循环、模块系统、异步 I/O、流、进程
2. 服务开发层：HTTP、路由、中间件、接口设计、数据库、缓存
3. 工程与上线层：日志、测试、安全、部署、监控、性能优化

1.2 学习主线

可以把 Node 服务学习主线记成：

运行时 -> 模块与异步 -> HTTP 服务 -> 框架 -> 数据库 -> 安全与部署

也就是说：

1. 先知道 Node 是怎么运行 JS 的
2. 再理解异步和 I/O
3. 再学如何提供 HTTP 服务
4. 再学框架如何组织项目
5. 最后补工程化能力

1.3 Node 学习的最终目标

真正学会 Node 服务，至少要做到：

1. 能独立起一个 API 服务
2. 能接数据库和缓存
3. 能做登录鉴权和权限控制
4. 能做日志、错误处理和测试
5. 能把服务部署上线

1.4 Node 服务常见技术栈

轻量 API 服务

1. Node.js
2. Express / Fastify
3. MySQL / PostgreSQL
4. Redis

中大型 TS 项目

1. Node.js
2. NestJS
3. Prisma / TypeORM
4. Redis
5. 消息队列

1.5 一句话记忆

Node 不只是“后端 JS”，而是一整套运行时 + 服务开发 + 工程化能力。

---

2. Node 到底是什么

2.1 Node.js 是什么

Node.js 是一个让 JavaScript 可以运行在浏览器之外的运行时环境。

重点：

1. Node 不是语言
2. JavaScript 才是语言
3. Node 提供了服务端需要的运行时能力

2.2 Node 能做什么

Node 常见用途：

1. Web 服务
2. 中间层 BFF
3. SSR 服务
4. 构建工具
5. 脚本工具
6. CLI 工具
7. 实时通信服务
8. 网关、代理、任务调度

2.3 Node 为什么适合做 I/O 密集型服务

因为 Node 的特点是：

1. 单线程执行 JavaScript
2. 异步非阻塞 I/O
3. 事件驱动

这让它在以下场景很有优势：

1. API 网关
2. Web 服务
3. 中间层聚合接口
4. 聊天和长连接
5. 文件上传下载

2.4 Node 的优缺点

优点

1. 前后端语言统一
2. I/O 场景性能和开发效率都不错
3. 包生态丰富
4. 启动快，适合中小服务和网关层

缺点

1. 不适合重 CPU 计算场景直接硬顶
2. 回调、异步和状态复杂时容易出错
3. 包生态丰富也意味着质量参差不齐

2.5 Node 和浏览器环境区别

浏览器常见对象

1. window
2. document
3. DOM API

Node 常见对象

1. global
2. process
3. Buffer
4. 文件系统 API
5. 网络和进程 API

2.6 Node 学习记忆口诀

JavaScript 是语言，Node 是运行时；Node 擅长 I/O，不擅长硬核计算。

---

3. Node 基础环境与工程入口

3.1 版本选择建议

学习和项目开发时，优先使用 当前 Node LTS 版本。

原因：

1. 稳定
2. 生态兼容性更好
3. 线上项目更常见

3.2 包管理器

常见：

1. npm
2. pnpm
3. yarn

推荐理解：

1. npm 是默认标准
2. pnpm 在很多团队里更受欢迎，因为依赖管理更高效

3.3 package.json 是什么

package.json 是项目的核心描述文件。

常见字段：

1. name
2. version
3. scripts
4. dependencies
5. devDependencies
6. type

示例：

{
  "name": "node-service-demo",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "dev": "node index.js",
    "start": "node index.js"
  }
}

3.4 dependencies 和 devDependencies 区别

dependencies

运行时依赖，线上环境需要。

devDependencies

开发时依赖，例如：

1. 测试库
2. 代码检查
3. 构建工具

3.5 scripts 的价值

通过 scripts 可以统一项目命令。

例如：

1. dev
2. start
3. test
4. lint
5. build

3.6 模块系统：CommonJS 和 ESM

这是 Node 面试高频。

CommonJS

const fs = require('fs')
module.exports = {}

ESM

import fs from 'node:fs'
export default {}

3.7 CommonJS 和 ESM 区别

1. require/module.exports vs import/export
2. 加载时机和语法标准不同
3. Node 现代项目越来越多使用 ESM

3.8 type: module 的作用

当 package.json 设置：

{
  "type": "module"
}

项目内 .js 会按 ESM 解释。

3.9 环境变量

服务端开发中常把敏感配置放在环境变量里，例如：

1. 端口
2. 数据库连接串
3. Redis 地址
4. JWT 密钥

Node 中通过：

process.env.PORT

读取。

3.10 工程入口文件

一个最简单的 Node 服务入口可能是：

import http from 'node:http'

const server = http.createServer((req, res) => {
  res.end('hello node')
})

server.listen(3000, () => {
  console.log('server running at http://localhost:3000')
})

3.11 基础环境口诀

package.json 管项目，scripts 管命令，env 管配置，模块系统分 CJS 和 ESM。

---

4. Node 核心运行机制

4.1 单线程到底是什么意思

Node 常说“单线程”，准确说法是：

1. JavaScript 执行主线程是单线程的
2. 但 Node 底层并不是只有一根线程

很多 I/O 操作和底层调度，不是靠 JS 主线程硬做完的。

4.2 事件驱动怎么理解

Node 的很多工作模式是：

1. 注册事件或回调
2. 等待事件发生
3. 事件到来时执行处理逻辑

典型例子：

1. HTTP 请求到达
2. 文件读取完成
3. 定时器触发
4. socket 消息到来

4.3 非阻塞 I/O 是什么

非阻塞 I/O 指的是：

发起 I/O 操作后，JavaScript 主线程不用一直傻等结果返回。

例如读取文件：

import fs from 'node:fs'

fs.readFile('./a.txt', 'utf-8', (err, data) => {
  console.log(data)
})

console.log('继续执行')

这里 readFile 发起后，后面的代码还能继续执行。

4.4 libuv 是什么

理解层面可以记住：

libuv 是 Node 底层很关键的事件循环和异步 I/O 支撑库。

你面试里不用把它讲太深，但要知道：

1. Node 的事件循环和很多异步能力离不开它
2. Node 的很多 I/O 并不是 JS 主线程直接完成

4.5 进程和线程

进程

操作系统中的资源分配单位。

线程

CPU 调度执行单位。

Node 服务开发中要先建立这个概念：

1. 一个 Node 服务实例通常是一个进程
2. JS 代码在该进程中的主线程执行

4.6 EventEmitter

Node 中很多模块基于事件机制，核心类就是 EventEmitter。

import { EventEmitter } from 'node:events'

const bus = new EventEmitter()

bus.on('ready', (msg) => {
  console.log(msg)
})

bus.emit('ready', 'node is ready')

4.7 EventEmitter 常见方法

1. on
2. once
3. emit
4. off

4.8 Node 核心机制口诀

JS 主线程单线程，I/O 走异步，事件驱动是主线，底层调度靠运行时。

---

5. 核心模块

Node 学服务端，核心模块一定要熟，因为很多框架能力本质都建立在这些模块之上。

5.1 path

用于处理路径。

常见方法：

1. join
2. resolve
3. basename
4. dirname
5. extname

import path from 'node:path'

console.log(path.join('/user', 'docs', 'a.txt'))

5.2 fs

文件系统模块。

常见能力：

1. 读文件
2. 写文件
3. 创建目录
4. 删除文件
5. 判断状态

import fs from 'node:fs/promises'

const content = await fs.readFile('./a.txt', 'utf-8')

5.3 http

Node 原生 HTTP 服务模块。

常用于：

1. 理解服务端本质
2. 手写简单服务
3. 理解框架底层

5.4 url

用于解析 URL。

const url = new URL('https://example.com/user?id=1')
console.log(url.pathname)
console.log(url.searchParams.get('id'))

5.5 os

获取系统信息，例如：

1. CPU
2. 内存
3. 平台信息

5.6 crypto

用于：

1. 哈希
2. 加密
3. 随机数
4. 签名

服务端场景很常见：

1. 密码散列
2. token 签名
3. 唯一 ID 生成

5.7 stream

流是 Node 核心中的核心，后面单独展开。

5.8 events

事件模块，支持发布订阅式编程。

5.9 process

代表当前 Node 进程。

常见用途：

1. 读取环境变量
2. 获取参数
3. 监听退出
4. 获取进程 ID

console.log(process.pid)
console.log(process.env.NODE_ENV)

5.10 child_process

用于创建子进程。

适合：

1. 调用系统命令
2. 执行脚本
3. 把重任务放到子进程

5.11 worker_threads

用于多线程处理重 CPU 任务。

适合：

1. 图像处理
2. 加密计算
3. 大数据计算

5.12 核心模块口诀

path 管路径，fs 管文件，http 管服务，crypto 管安全，stream 管大数据流，process 管进程。

---

6. 异步编程与事件循环

6.1 Node 为什么要重视异步

因为服务端绝大多数工作都和 I/O 有关：

1. 读数据库
2. 调接口
3. 读写文件
4. 网络收发

如果都同步阻塞，吞吐量会很差。

6.2 常见异步写法演进

1. 回调函数
2. Promise
3. async/await

6.3 回调地狱问题

getUser((user) => {
  getOrders(user.id, (orders) => {
    getDetail(orders[0].id, (detail) => {
      console.log(detail)
    })
  })
})

问题：

1. 嵌套深
2. 错误处理难
3. 可读性差

6.4 Promise 和 async/await

现代 Node 服务端代码基本以 Promise + async/await 为主。

async function main() {
  const user = await getUser()
  const orders = await getOrders(user.id)
  return orders
}

6.5 错误处理

服务端里错误处理必须重视。

try {
  const data = await service()
  return data
} catch (error) {
  console.error(error)
}

6.6 事件循环怎么记

Node 事件循环是面试高频。

你先记住大原则：

1. 同步代码先执行
2. 不同异步任务会进入不同队列或阶段
3. 事件循环会不断处理这些任务

6.7 Node 事件循环常见阶段

理解层面可以记住：

1. timers
2. pending callbacks
3. idle / prepare
4. poll
5. check
6. close callbacks

6.8 setTimeout、setImmediate、process.nextTick

这是经典面试题。

setTimeout(fn, 0)

放到 timers 相关阶段。

setImmediate(fn)

通常在 check 阶段执行。

process.nextTick(fn)

优先级更特殊，通常会在当前阶段结束后尽快执行。

6.9 Promise 微任务

Node 中也有微任务概念，例如：

1. Promise.then
2. queueMicrotask

6.10 面试答法建议

不要死背极端输出题，先把主线答清：

1. Node 有事件循环
2. 定时器、I/O 回调、立即执行回调等分布在不同阶段
3. 微任务和 process.nextTick 还有自己的优先执行时机

6.11 异步编程口诀

服务端先学 async/await，再理解事件循环；nextTick 更急，Promise 属于微任务。

---

7. Buffer、Stream 与文件处理

Node 服务端和前端最大的体验差异之一，就是会大量接触 Buffer、流、文件和网络数据。

7.1 Buffer 是什么

Buffer 是 Node 中处理二进制数据的重要类型。

为什么需要它：

1. 文件是二进制
2. 网络传输常常是二进制
3. 图片、音频、压缩包都离不开它

const buf = Buffer.from('hello')
console.log(buf)
console.log(buf.toString())

7.2 Stream 是什么

流可以理解成：

数据不是一次性全部处理，而是一边来一边处理

好处：

1. 节省内存
2. 更适合大文件
3. 更适合网络传输

7.3 四种常见流

1. Readable
2. Writable
3. Duplex
4. Transform

7.4 什么时候应该用流

典型场景：

1. 大文件下载
2. 文件上传
3. 日志处理
4. 文件压缩
5. 代理转发

7.5 文件读取：一次性 vs 流式

一次性读取

const data = await fs.readFile('./big.log')

问题：

1. 文件大时占内存高

流式读取

import fs from 'node:fs'

const stream = fs.createReadStream('./big.log')
stream.on('data', (chunk) => {
  console.log(chunk.length)
})

7.6 pipe 是什么

可以把读取流直接接到写入流。

readStream.pipe(writeStream)

7.7 背压怎么理解

当生产数据的速度大于消费速度时，就会有背压问题。

流机制能帮助控制这种速度差。

7.8 Buffer 和 Stream 口诀

Buffer 管二进制，Stream 管大数据；小文件可整读，大文件优先流式。

---

8. HTTP 服务与接口开发

8.1 一个 HTTP 服务最基本需要什么

最小化思维：

1. 监听端口
2. 接收请求
3. 解析路径和方法
4. 返回响应

8.2 原生 HTTP 示例

import http from 'node:http'

const server = http.createServer((req, res) => {
  if (req.method === 'GET' && req.url === '/health') {
    res.writeHead(200, { 'Content-Type': 'application/json' })
    res.end(JSON.stringify({ ok: true }))
    return
  }

  res.writeHead(404)
  res.end('Not Found')
})

server.listen(3000)

8.3 请求里常处理什么

1. method
2. path
3. query
4. headers
5. body
6. cookies

8.4 响应里常处理什么

1. 状态码
2. headers
3. JSON 数据
4. 错误信息

8.5 常见 HTTP 方法

1. GET
2. POST
3. PUT
4. PATCH
5. DELETE

8.6 常见状态码

1. 200 成功
2. 201 创建成功
3. 400 参数错误
4. 401 未认证
5. 403 无权限
6. 404 不存在
7. 500 服务器错误

8.7 RESTful API 怎么理解

可以先这样记：

1. URL 表示资源
2. 方法表示动作
3. 状态码表达结果

例如：

1. GET /users
2. GET /users/:id
3. POST /users
4. PATCH /users/:id
5. DELETE /users/:id

8.8 中间件是什么

中间件可以理解成：

在请求到响应之间插入的一层层处理逻辑

常见用途：

1. 日志
2. 鉴权
3. 参数解析
4. 错误处理
5. 跨域

8.9 服务端项目常见目录设计

推荐理解为分层：

1. routes
2. controllers
3. services
4. models
5. middlewares
6. utils
7. config

8.10 接口开发口诀

请求先过中间件，控制器收参数，服务层写业务，状态码表达结果。

---

9. 常见服务端框架

学 Node 服务，框架不是越多越好，而是要知道各自定位。

9.1 Express

特点

1. 经典
2. 轻量
3. 中间件生态成熟
4. 上手快

适合场景

1. 学习 Node 服务
2. 小中型 API 服务
3. 中间层和工具服务

示例

import express from 'express'

const app = express()

app.get('/health', (req, res) => {
  res.json({ ok: true })
})

app.listen(3000)

9.2 Koa

特点

1. 更轻
2. 更强调中间件洋葱模型
3. API 更现代

适合场景

1. 理解中间件模型
2. 定制化服务
3. 想更灵活控制框架层

9.3 Fastify

特点

1. 性能好
2. 插件化设计强
3. Schema 驱动更明显

适合场景

1. 追求吞吐和性能
2. API 服务
3. 结构清晰、可扩展的中后台服务

9.4 NestJS

特点

1. 更完整的工程化框架
2. 强调模块化、依赖注入、装饰器
3. 非常适合 TypeScript

适合场景

1. 中大型项目
2. 团队协作
3. 复杂业务系统
4. 规范化企业应用

9.5 这几个框架怎么选

学习起步

优先：

1. Express

因为最容易理解 HTTP、中间件、路由和服务开发主线。

想要更高性能和更现代

可以看：

1. Fastify

想理解中间件模型和更轻抽象

可以看：

1. Koa

想做规范化大型项目

可以看：

1. NestJS

9.6 框架对比速记

框架	关键词	适合
Express	经典、轻量、生态大	入门、小中型项目
Koa	洋葱模型、灵活	理解中间件、定制化
Fastify	高性能、Schema、插件	API 服务、性能导向
NestJS	模块化、DI、TS 友好	中大型企业项目

9.7 框架学习建议

推荐顺序：

1. 先学原生 HTTP
2. 再学 Express
3. 再理解 Koa / Fastify / NestJS 的差异

9.8 框架口诀

Express 好入门，Koa 看中间件，Fastify 重性能，NestJS 重工程化。

---

10. 数据库与缓存

10.1 服务端为什么必须学数据库

因为绝大多数服务都要处理：

1. 用户数据
2. 业务数据
3. 日志和记录
4. 权限和配置

10.2 常见数据库

MySQL / PostgreSQL

关系型数据库，适合结构化业务数据。

MongoDB

文档型数据库，适合灵活结构场景。

10.3 常见 Node 数据访问方式

1. 原生 SQL
2. Query Builder
3. ORM / ODM

10.4 常见 ORM 工具

1. Prisma
2. TypeORM
3. Sequelize
4. Mongoose

10.5 Redis 是什么

Redis 常用于：

1. 缓存
2. Session
3. 分布式锁
4. 排行榜
5. 计数器
6. 消息队列轻场景

10.6 为什么缓存重要

因为数据库不是无限快的，缓存可以：

1. 降低数据库压力
2. 提高接口响应速度
3. 处理热点数据

10.7 数据一致性要注意什么

用了缓存后要注意：

1. 数据更新后缓存是否同步失效
2. 是否可能读到旧值
3. 是否要做过期策略

10.8 数据库设计学习重点

1. 表设计
2. 索引
3. 事务
4. 分页
5. N+1 查询问题

10.9 数据层口诀

主数据进数据库，热点数据进缓存；先设计结构，再谈 ORM。

---

11. 鉴权、安全与权限控制

11.1 为什么服务端必须重视安全

服务端直接暴露在网络上，常见风险包括：

1. 未授权访问
2. 参数注入
3. 密码泄露
4. 接口滥刷
5. 越权操作

11.2 常见登录鉴权方式

1. Session + Cookie
2. JWT
3. OAuth

11.3 JWT 怎么理解

JWT 是一种令牌方案。

常见流程：

1. 用户登录成功
2. 服务端签发 token
3. 客户端后续请求带上 token
4. 服务端校验 token

11.4 JWT 适合什么场景

1. 前后端分离
2. 多终端登录
3. 无状态认证需求

11.5 Session 和 JWT 怎么选

Session

1. 服务端集中管理会话
2. 更传统

JWT

1. 更适合前后端分离
2. 更常见于现代接口系统

11.6 权限控制

常见两层：

1. 认证：你是谁
2. 授权：你能做什么

11.7 密码处理原则

密码不能明文存储，应该：

1. 加盐
2. 哈希
3. 使用成熟库

11.8 常见安全问题

1. SQL 注入
2. XSS
3. CSRF
4. 暴力破解
5. 敏感信息泄露
6. 越权

11.9 基础安全手段

1. 参数校验
2. 限流
3. 日志审计
4. HTTPS
5. 合理的 CORS 配置
6. 敏感配置走环境变量

11.10 安全口诀

先认证，再授权；密码不明文，参数先校验，接口要限流。

---

12. 日志、调试、测试与监控

12.1 为什么服务端一定要有日志

没有日志，出问题时你几乎是盲的。

日志常见用途：

1. 问题排查
2. 行为审计
3. 性能分析
4. 线上追踪

12.2 日志要记什么

1. 请求信息
2. 响应状态
3. 错误堆栈
4. 关键业务事件
5. 慢接口

12.3 日志等级

常见：

1. info
2. warn
3. error
4. debug

12.4 调试方式

1. console.log
2. Node Inspector
3. IDE 调试
4. 接口日志

12.5 测试分层

单元测试

测函数、服务逻辑。

集成测试

测模块协作，如数据库和路由一起工作。

接口测试

测真实 API 表现。

12.6 Node 常见测试工具

1. Jest
2. Vitest
3. Supertest

12.7 监控看什么

1. CPU
2. 内存
3. QPS
4. 错误率
5. 响应时间
6. 慢查询

12.8 稳定性建设

1. 健康检查接口
2. 超时控制
3. 重试机制
4. 熔断和降级
5. 异常告警

12.9 可观测性口诀

没日志就没排查，没监控就没预警，没测试就没底气。

---

13. 部署与上线

13.1 一个 Node 服务上线要考虑什么

1. 环境变量
2. 进程管理
3. 日志收集
4. 反向代理
5. 监控告警
6. 自动化部署

13.2 常见部署方式

1. 直接部署到云服务器
2. Docker 容器化
3. Serverless
4. PaaS 平台

13.3 进程管理工具

常见：

1. PM2
2. systemd
3. 容器编排环境

13.4 为什么 Node 服务常放在 Nginx 后面

常见原因：

1. 反向代理
2. 负载均衡
3. 静态资源分发
4. HTTPS 终止

13.5 Docker 为什么重要

因为它能：

1. 统一运行环境
2. 提高部署一致性
3. 更方便和 CI/CD 配合

13.6 CI/CD 要知道什么

至少要理解：

1. 代码提交后自动测试
2. 自动构建镜像
3. 自动部署
4. 回滚机制

13.7 上线前检查清单

1. 环境变量是否配置完整
2. 日志是否可用
3. 错误处理是否统一
4. 健康检查接口是否存在
5. 数据库迁移是否正确
6. 监控告警是否就位

13.8 上线口诀

本地能跑不算上线，环境、进程、日志、监控、回滚都要有。

---

14. 高频面试题

14.1 Node 为什么适合做 I/O 密集型服务

答：

1. Node 的 JS 执行主线程是单线程
2. 但 I/O 采用异步非阻塞模型
3. 事件驱动让它很适合高并发 I/O 场景

14.2 Node 的事件循环怎么理解

答：

1. 同步代码先执行
2. 异步任务会进入不同阶段或队列
3. 事件循环按阶段不断处理任务
4. process.nextTick 和微任务又有更高优先级时机

14.3 CommonJS 和 ESM 区别

答：

1. 语法不同
2. 加载机制不同
3. Node 现代项目越来越多采用 ESM

14.4 Stream 为什么重要

答：

1. 适合大文件和大数据传输
2. 可以边读边处理
3. 节省内存
4. 是 Node 很核心的 I/O 模型

14.5 process.nextTick 和 setImmediate 区别

答题主线：

1. nextTick 会更早执行
2. setImmediate 通常在事件循环的 check 阶段
3. 不同场景下输出顺序要结合阶段理解

14.6 Express 中间件是什么

答：

中间件是请求和响应之间的一层层处理逻辑，常用于日志、鉴权、解析、错误处理等。

14.7 Session 和 JWT 区别

答：

1. Session 偏服务端会话存储
2. JWT 偏无状态令牌
3. 现代前后端分离场景更常见 JWT

14.8 Node 如何处理 CPU 密集型任务

答：

1. 不要直接堵塞主线程
2. 可以用 worker_threads
3. 或拆到子进程、消息队列、独立计算服务

14.9 为什么服务端更新要统一错误处理

答：

1. 保证接口返回格式一致
2. 便于日志记录和排查
3. 避免异常泄露内部信息

14.10 面试回答模板

服务端问题建议按这个顺序答：

1. 先说定义
2. 再说原理
3. 再说应用场景
4. 最后说注意点和工程实践

---

15. 8 小时学习规划

第 1 小时：Node 基础地图

目标：

1. 搞清 Node 是什么
2. 搞清包管理和模块系统
3. 搞清 CommonJS 与 ESM

必须掌握：

1. package.json
2. scripts
3. process.env

第 2 小时：核心运行机制

目标：

1. 理解单线程和异步 I/O
2. 理解事件驱动
3. 初步理解事件循环

必须掌握：

1. Node 为什么适合 I/O
2. EventEmitter
3. process.nextTick

第 3 小时：核心模块

目标：

1. 会用 fs
2. 会用 path
3. 会用 http
4. 初识 Buffer/Stream

第 4 小时：HTTP 服务与 Express

目标：

1. 先理解原生 HTTP
2. 再用 Express 起接口
3. 掌握路由、中间件、错误处理

第 5 小时：数据库与缓存

目标：

1. 接 MySQL 或 PostgreSQL
2. 理解 ORM
3. 理解 Redis 缓存

第 6 小时：鉴权与安全

目标：

1. 理解 Session 和 JWT
2. 理解密码处理
3. 理解参数校验、限流、权限控制

第 7 小时：框架认知升级

目标：

1. 了解 Koa
2. 了解 Fastify
3. 了解 NestJS 的定位

第 8 小时：工程化与上线

目标：

1. 日志
2. 测试
3. 监控
4. Docker
5. PM2 / 部署主线

建议：

1. 手写一个 Express CRUD 服务
2. 接一个数据库
3. 加 JWT 登录
4. 加统一错误处理和日志

---

16. 一页速记总结

16.1 Node 核心定位

1. 运行时，不是语言
2. 单线程 JS + 异步 I/O
3. 适合 I/O 密集型服务

16.2 必会模块

1. fs
2. path
3. http
4. process
5. crypto
6. stream

16.3 服务开发主线

1. 路由
2. 中间件
3. 控制器
4. 服务层
5. 数据层

16.4 框架选型

1. Express：入门和轻量项目
2. Koa：理解中间件与灵活定制
3. Fastify：性能导向
4. NestJS：大型 TS 工程

16.5 工程重点

1. 数据库
2. Redis
3. JWT
4. 日志
5. 测试
6. 部署

---

17. 背诵口诀

17.1 Node 基础口诀

Node 是运行时，不是新语言；JS 线程跑逻辑，I/O 异步不阻塞。

17.2 服务开发口诀

请求先进中间件，控制器拿参数，服务层写业务，数据层管存储。

17.3 框架口诀

Express 好入门，Koa 看洋葱，Fastify 重性能，NestJS 重工程。

17.4 工程化口诀

有日志才好查，有测试才敢改，有监控才放心，有部署才算完。

---

18. 最后给你的建议

如果你想真正把 Node 服务学会，最有效的顺序不是死看概念，而是：

1. 先用原生 http 写一个最小服务
2. 再用 Express 写一个 CRUD 项目
3. 接数据库和 Redis
4. 加登录鉴权、统一错误处理、日志
5. 最后再补 NestJS、Fastify 和部署能力

真正学会的标准不是“看懂文章”，而是：

1. 你能自己起服务
2. 你能自己设计接口
3. 你能自己接数据库
4. 你能自己处理错误和安全
5. 你能把服务部署起来

只要把这五步跑通，Node 服务端能力就真正立起来了。