罗罗编程学习记录
本页内容 展开查看

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) => {},四个参数的中间件。

原理流程

  1. 请求进来,Express 按注册顺序执行中间件。
  2. 每个中间件处理完,调用 next(),进入下一个中间件。
  3. 最后一个中间件处理完,返回响应。
  4. 如果中间件出错,调用 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 就行。
  • 特点:更灵活,可以在响应后做日志、计时等操作。

原理流程

  1. 请求进来,先执行第一个中间件的前置部分。
  2. 调用 next(),进入第二个中间件的前置部分。
  3. 一直到最内层的中间件,处理完请求,开始返回。
  4. 从最内层往外,执行每个中间件的后置部分。
  5. 像洋葱一样,从外到里,再从里到外。

代码 / 示例

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 那样包装很多层。

原理流程

  1. Fastify 启动时,根据路由 Schema 预编译 JSON 序列化函数。
  2. 请求进来时,直接用预编译的函数序列化响应,不用每次都分析对象结构。
  3. 路由匹配用高效的前缀树,比 Express 的逐个匹配快。
  4. 中间件开销低,请求处理路径短。

代码 / 示例

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 服务。

原理流程

  1. 看项目需求:要快速开发,选 Express,中间件什么都有。
  2. 看团队风格:喜欢 async/await 和洋葱模型,选 Koa。
  3. 看性能要求:高并发 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)放最前面。
    • 路由中间件放后面。
    • 错误处理中间件放最后面。

原理流程

  1. 请求进来,按注册顺序过每个中间件。
  2. 每个中间件调用 next(),进入下一个。
  3. 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 错误,自动到错误处理钩子。

原理流程

  1. Express 4:async 函数里 throw 错误,不会自动到错误处理中间件。
  2. Koa:async 函数里 throw 错误,会自动冒泡到最外层。
  3. 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 数据