04.2.4.1 Express/Koa/Fastify 对照
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.2 Node.js / 04.2.4 Web 框架对照
覆盖范围
- Express:中间件线性模型、生态最大
- Koa:洋葱模型、async/await、轻量
- Fastify:高性能、内置 Schema 校验、插件化
- 三者中间件执行模型对比
- 选型建议
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 04.2.4.1-001 | Express 中间件模型 | 进阶 | ★★★★★ |
| 04.2.4.1-002 | Koa 和 Express 区别 | 进阶 | ★★★★☆ |
| 04.2.4.1-003 | Koa 洋葱模型 | 进阶 | ★★★★☆ |
| 04.2.4.1-004 | Fastify 特点 | 进阶 | ★★★★☆ |
| 04.2.4.1-005 | Fastify 为什么比 Express 快 | 进阶 | ★★★★☆ |
| 04.2.4.1-006 | 中间件执行顺序 | 进阶 | ★★★★☆ |
| 04.2.4.1-007 | 错误处理方式区别 | 进阶 | ★★★☆☆ |
| 04.2.4.1-008 | 怎么选这三个框架 | 基础 | ★★★★☆ |
04.2.4.1-001 Express 的中间件模型是什么?
频率 ★★★★★ | 难度 进阶
一句话结论
Express 中间件是线性的:请求进来,按顺序执行每个中间件,每个中间件调用 next() 进入下一个;响应时原路返回,但 Express 没有响应阶段的中间件钩子,只能在 next() 之前写逻辑。
概念解释
- Express 中间件:(req, res, next) => {}。
- 线性模型:请求从第一个中间件走到最后一个,每个中间件调用 next() 才能进入下一个。
- 特点:简单直接,但没有"响应阶段"的概念,要在 next() 之后写响应后的逻辑(但 Express 不推荐这样)。
- 错误处理:(err, req, res, next) => {},四个参数的中间件。
原理流程
- 请求进来,Express 按注册顺序执行中间件。
- 每个中间件处理完,调用 next(),进入下一个中间件。
- 最后一个中间件处理完,返回响应。
- 如果中间件出错,调用 next(err),进入错误处理中间件。
代码 / 示例
const express = require('express');
const app = express();
// 中间件1:日志
app.use((req, res, next) => {
console.log(`${req.method} ${req.url}`);
next(); // 进入下一个中间件
});
// 中间件2:解析 body
app.use(express.json());
// 路由
app.get('/users', (req, res) => {
res.json([{ id: 1, name: 'Alice' }]);
});
// 错误处理中间件
app.use((err, req, res, next) => {
console.error(err);
res.status(500).json({ error: '服务器错误' });
});
app.listen(3000);
常见误区
- 误区:Express 中间件可以在响应后执行?正解:Express 没有洋葱模型,响应后中间件不会再执行;要在 next() 之后写逻辑是 hack,不推荐。
- 误区:Express 原生支持 async/await?正解:Express 4 不原生支持 async 错误捕获,要自己包装或用 express-async-errors。
追问 / 延伸
- Express 5 有什么改进?答:原生支持 async/await 错误捕获,路由匹配更严格,移除了已废弃的 API。
- 什么是中间件栈?答:Express 内部维护一个中间件数组,按顺序执行。
04.2.4.1-003 Koa 的洋葱模型是什么?
频率 ★★★★☆ | 难度 进阶
一句话结论
Koa 的洋葱模型:中间件像洋葱一样层层包裹,请求从外层进入内层,响应从内层返回到外层;每个中间件可以在 next() 前后都写逻辑,实现"前置"和"后置"。
概念解释
- 洋葱模型:中间件是嵌套的,请求从外到里,响应从里到外。
- 每个中间件有两个阶段:next() 之前(请求阶段)、next() 之后(响应阶段)。
- Koa 原生支持 async/await,错误处理用 try-catch 就行。
- 特点:更灵活,可以在响应后做日志、计时等操作。
原理流程
- 请求进来,先执行第一个中间件的前置部分。
- 调用 next(),进入第二个中间件的前置部分。
- 一直到最内层的中间件,处理完请求,开始返回。
- 从最内层往外,执行每个中间件的后置部分。
- 像洋葱一样,从外到里,再从里到外。
代码 / 示例
const Koa = require('koa');
const app = new Koa();
// 中间件1:外层,记录耗时
app.use(async (ctx, next) => {
const start = Date.now();
console.log('请求开始');
await next(); // 进入下一个中间件
const duration = Date.now() - start;
console.log(`响应结束,耗时 ${duration}ms`);
});
// 中间件2:解析 body
app.use(async (ctx, next) => {
console.log('处理请求');
await next();
console.log('处理响应');
});
// 路由
app.use(async (ctx) => {
ctx.body = { message: 'Hello Koa' };
});
app.listen(3000);
// 输出顺序:
// 请求开始
// 处理请求
// 处理响应
// 响应结束,耗时 xxms
常见误区
- 误区:Koa 洋葱模型就是 Express 中间件?正解:Express 是线性的,只有请求阶段;Koa 洋葱模型有请求和响应两个阶段。
- 误区:Koa 比 Express 快?正解:Koa 本身很轻量,但生态不如 Express,很多中间件要自己写。
追问 / 延伸
- Koa 和 Express 是谁做的?答:都是 Express 原班人马,Express 是早期的,Koa 是后来重写的,基于 async/await。
- 什么是 ctx 对象?答:Koa 把 request 和 response 合并成一个 ctx 对象,方便操作。
04.2.4.1-005 Fastify 为什么比 Express 快?
频率 ★★★★☆ | 难度 进阶
一句话结论
Fastify 快主要因为:内置 JSON Schema 序列化(比 JSON.stringify 快 2-5 倍)、路由树优化、原生 async/await、低开销的请求处理;适合高性能 API 场景。
概念解释
- Fastify 特点:
- 高性能:比 Express 快 2-4 倍(官方 benchmark)。
- 内置 Schema 校验:用 JSON Schema 校验请求和序列化响应。
- 插件化:架构和 Koa 类似,插件机制。
- 原生 async/await。
- 快的原因:
- 使用 fast-json-stringify 序列化响应,比 JSON.stringify 快很多。
- 路由树用 find-my-way,比 Express 的正则匹配快。
- 低开销的请求封装,不像 Express 那样包装很多层。
原理流程
- Fastify 启动时,根据路由 Schema 预编译 JSON 序列化函数。
- 请求进来时,直接用预编译的函数序列化响应,不用每次都分析对象结构。
- 路由匹配用高效的前缀树,比 Express 的逐个匹配快。
- 中间件开销低,请求处理路径短。
代码 / 示例
const fastify = require('fastify')({ logger: true });
// 定义 Schema
const schema = {
response: {
200: {
type: 'object',
properties: {
id: { type: 'number' },
name: { type: 'string' },
},
},
},
};
fastify.get('/users/:id', { schema }, async (request, reply) => {
return { id: Number(request.params.id), name: 'Alice' };
});
fastify.listen({ port: 3000 });
常见误区
- 误区:Fastify 比所有框架都快?正解:Fastify 在 JSON API 场景下很快,但如果响应不是 JSON,优势就小了。
- 误区:Fastify 没有生态?正解:Fastify 有很多插件,生态在增长,但不如 Express 大。
追问 / 延伸
- 什么是 fast-json-stringify?答:根据 JSON Schema 预编译序列化函数,比 JSON.stringify 快很多,因为不用每次都分析对象结构。
- 什么是 Schema 校验?答:用 JSON Schema 定义请求参数的格式,Fastify 自动校验,不合法就返回 400。
04.2.4.1-008 怎么选 Express/Koa/Fastify?
频率 ★★★★☆ | 难度 基础
一句话结论
小项目或快速原型用 Express(生态最大、资料最多);需要优雅的中间件模型和 async/await 用 Koa;高性能 JSON API 用 Fastify。
概念解释
- Express:生态最大、资料最多、最简单,适合大多数场景。
- Koa:更优雅的洋葱模型、原生 async/await、轻量,适合喜欢现代风格的项目。
- Fastify:高性能、内置 Schema 校验,适合高并发 JSON API 服务。
原理流程
- 看项目需求:要快速开发,选 Express,中间件什么都有。
- 看团队风格:喜欢 async/await 和洋葱模型,选 Koa。
- 看性能要求:高并发 API,选 Fastify。
代码 / 示例
选型决策树:
1. 项目要快速上线,需要各种中间件? → Express
2. 团队喜欢现代风格,要洋葱模型? → Koa
3. 高并发 JSON API,性能要求高? → Fastify
常见误区
- 误区:一定要选最新的框架?正解:Express 虽然老,但生态成熟、坑都被踩过了,生产环境很稳。
- 误区:Fastify 一定比 Express 好?正解:Fastify 有优势,但学习成本和生态不如 Express,要看场景。
追问 / 延伸
- 什么是 NestJS?答:基于 Express 或 Fastify 的企业级框架,自带 DI、模块系统,适合大型项目。
- 什么是 Hono?答:新一代轻量 Web 框架,跑在各种运行时(Node、Deno、Bun、Edge),非常快。
04.2.4.1-006 中间件执行顺序是怎样的?
频率 ★★★★☆ | 难度 进阶
一句话结论
Express 中间件按注册顺序执行,先注册的先执行;Koa 洋葱模型按注册顺序进入,响应时按相反顺序返回;执行顺序很重要,比如日志要在最外面,CORS 要在最前面。
概念解释
- Express:线性执行,注册顺序就是执行顺序。
- Koa:洋葱模型,请求从外到里,响应从里到外。
- 顺序原则:
- 通用中间件(日志、CORS、请求 ID)放最前面。
- 路由中间件放后面。
- 错误处理中间件放最后面。
原理流程
- 请求进来,按注册顺序过每个中间件。
- 每个中间件调用 next(),进入下一个。
- Koa 洋葱模型,next() 之后的代码在响应阶段执行。
代码 / 示例
// Express:执行顺序就是注册顺序
app.use(loggingMiddleware); // 1. 先执行
app.use(corsMiddleware); // 2. 再执行
app.use(express.json()); // 3. 再执行
app.get('/users', userHandler); // 4. 最后执行
app.use(errorHandler); // 5. 错误处理放最后
// Koa:洋葱模型
app.use(async (ctx, next) => {
console.log('1. 请求开始');
await next();
console.log('1. 响应结束');
});
app.use(async (ctx, next) => {
console.log('2. 请求开始');
await next();
console.log('2. 响应结束');
});
// 输出顺序:
// 1. 请求开始
// 2. 请求开始
// 2. 响应结束
// 1. 响应结束
常见误区
- 误区:中间件顺序不重要?正解:顺序很重要,比如 CORS 要在最前面,否则其他中间件报错就不会过 CORS。
- 误区:错误处理中间件放哪里都一样?正解:错误处理中间件必须放最后面,前面的中间件出错才会走到它。
追问 / 延伸
- 什么是错误处理中间件?答:四个参数 (err, req, res, next) 的中间件,专门处理错误。
- 什么是路由级中间件?答:只对某个路由生效的中间件,不是全局的。
04.2.4.1-007 三个框架的错误处理方式有什么区别?
频率 ★★★☆☆ | 难度 进阶
一句话结论
Express 4 不原生支持 async 错误,要手动包装或用 express-async-errors;Koa 原生支持 async/await,try-catch 就行;Fastify 原生支持 async 错误,自动捕获。
概念解释
- Express 4:
- 不原生支持 async/await 错误捕获。
- async 函数里 throw 错误,会变成未处理的 Promise rejection,不会到错误处理中间件。
- 解决:用 express-async-errors 包,或手动包装。
- Koa:
- 原生支持 async/await。
- 错误会自动冒泡到最外层,中间件里 try-catch 就行。
- Fastify:
- 原生支持 async 错误。
- 路由里 throw 错误,自动到错误处理钩子。
原理流程
- Express 4:async 函数里 throw 错误,不会自动到错误处理中间件。
- Koa:async 函数里 throw 错误,会自动冒泡到最外层。
- Fastify:async 函数里 throw 错误,自动到 setErrorHandler。
代码 / 示例
// Express 4:async 错误不会自动捕获
app.get('/users', async (req, res) => {
throw new Error('出错了'); // 这个错误不会到错误处理中间件
});
// 解决:用 express-async-errors
require('express-async-errors');
// Koa:原生支持
app.use(async (ctx, next) => {
try {
await next();
} catch (err) {
ctx.status = 500;
ctx.body = { error: err.message };
}
});
// Fastify:原生支持
fastify.setErrorHandler((err, req, reply) => {
reply.code(500).send({ error: err.message });
});
常见误区
- 误区:Express 原生支持 async 错误?正解:Express 4 不原生支持,要装 express-async-errors;Express 5 原生支持了。
- 误区:错误处理中间件能捕获所有错误?正解:Express 4 里 async 错误捕获不到,要手动包装。
追问 / 延伸
- Express 5 有什么改进?答:原生支持 async/await 错误捕获,路由匹配更严格。
- 什么是未处理的 Promise rejection?答:Promise 里 throw 了错误,但没有 catch,Node 会打印警告。
待整理清单
- [ ] Hono 与 Bun 运行时
- [ ] 各框架中间件生态对比
- [ ] Node.js Web 框架 benchmark 数据