跳至主要內容

koa和express差异

pax大约 5 分钟

Koa 和 Express 是两个非常流行的 Node.js Web 框架，它们有很多相似之处，但也有显著的区别。让我详细对比这两个框架：

1. 设计理念和架构

Express - 传统回调式设计

const express = require('express');
const app = express();

// Express 使用回调函数处理异步操作
app.use((req, res, next) => {
  // 传统回调方式
  someAsyncOperation((err, result) => {
    if (err) return next(err);
    req.data = result;
    next();
  });
});

app.get('/', (req, res, next) => {
  res.send('Hello World');
});

app.listen(3000);

Koa - 现代异步/等待设计

const Koa = require('koa');
const app = new Koa();

// Koa 使用 async/await 处理异步操作
app.use(async (ctx, next) => {
  try {
    ctx.data = await someAsyncOperation();
    await next();
  } catch (err) {
    ctx.throw(500, err);
  }
});

app.use(async (ctx, next) => {
  ctx.body = 'Hello World';
});

app.listen(3000);

2. 中间件系统

Express - 线性中间件模型

const express = require('express');
const app = express();

app.use((req, res, next) => {
  console.log('中间件1开始');
  next();
  console.log('中间件1结束'); // 这在响应发送后执行
});

app.use((req, res, next) => {
  console.log('中间件2');
  res.send('Hello');
  next(); // 响应已发送，这不会影响客户端
});

app.listen(3000);

Koa - 洋葱模型中间件

const Koa = require('koa');
const app = new Koa();

app.use(async (ctx, next) => {
  console.log('中间件1开始');
  await next();
  console.log('中间件1结束'); // 这在响应发送前执行
});

app.use(async (ctx, next) => {
  console.log('中间件2');
  ctx.body = 'Hello';
  await next();
  console.log('中间件2清理工作');
});

app.listen(3000);

执行顺序对比：

  • Express: 1开始 → 2 → 1结束
  • Koa: 1开始 → 2开始 → 2清理 → 1结束

3. 请求和响应对象

Express - 传统 req/res 对象

const express = require('express');
const app = express();

app.use((req, res, next) => {
  // Express 使用 req 和 res 对象
  console.log('URL:', req.url);
  console.log('Method:', req.method);
  console.log('Query:', req.query);
  console.log('Body:', req.body);
  
  // 响应操作
  res.status(200);
  res.set('Content-Type', 'text/plain');
  res.send('Hello World');
  
  next();
});

Koa - 上下文对象

const Koa = require('koa');
const app = new Koa();

app.use(async (ctx, next) => {
  // Koa 使用 ctx 对象，整合了 req 和 res
  console.log('URL:', ctx.url);
  console.log('Method:', ctx.method);
  console.log('Query:', ctx.query);
  console.log('Request Body:', ctx.request.body);
  
  // 响应操作
  ctx.status = 200;
  ctx.set('Content-Type', 'text/plain');
  ctx.body = 'Hello World';
  
  await next();
});

4. 错误处理

Express - 错误处理中间件

const express = require('express');
const app = express();

// 错误处理中间件（必须有4个参数）
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

app.get('/', (req, res) => {
  throw new Error('Something went wrong');
});

app.listen(3000);

Koa - try/catch 错误处理

const Koa = require('koa');
const app = new Koa();

// 统一错误处理
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.status = err.status || 500;
    ctx.body = { message: err.message };
    ctx.app.emit('error', err, ctx);
  }
});

// 全局错误监听
app.on('error', (err, ctx) => {
  console.error('Error occurred:', err);
});

app.use(async (ctx, next) => {
  throw new Error('Something went wrong');
});

app.listen(3000);

5. 异步操作处理

Express - 回调和 Promise

const express = require('express');
const app = express();

// 回调方式
app.get('/callback', (req, res, next) => {
  getUserById(req.params.id, (err, user) => {
    if (err) return next(err);
    res.json(user);
  });
});

// Promise 方式
app.get('/promise', (req, res, next) => {
  getUserById(req.params.id)
    .then(user => res.json(user))
    .catch(next);
});

// async/await 方式（需要 express 5.x 或额外配置）
app.get('/async', async (req, res, next) => {
  try {
    const user = await getUserById(req.params.id);
    res.json(user);
  } catch (err) {
    next(err);
  }
});

Koa - 原生支持 async/await

const Koa = require('koa');
const app = new Koa();

// Koa 原生支持 async/await
app.use(async (ctx, next) => {
  const user = await getUserById(ctx.params.id);
  ctx.body = user;
  await next();
});

// 错误处理更简单
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.throw(500, err.message);
  }
});

6. 路由系统

Express - 内置路由

const express = require('express');
const app = express();
const router = express.Router();

// 路由定义
router.get('/users/:id', (req, res) => {
  res.json({ id: req.params.id, name: 'John' });
});

router.post('/users', (req, res) => {
  res.status(201).json({ message: 'User created' });
});

app.use('/api', router);
app.listen(3000);

Koa - 需要额外路由中间件

const Koa = require('koa');
const Router = require('@koa/router');
const app = new Koa();
const router = new Router();

// 路由定义
router.get('/users/:id', async (ctx, next) => {
  ctx.body = { id: ctx.params.id, name: 'John' };
});

router.post('/users', async (ctx, next) => {
  ctx.status = 201;
  ctx.body = { message: 'User created' };
});

app.use(router.routes());
app.use(router.allowedMethods());
app.listen(3000);

7. 中间件生态系统

Express - 丰富的中间件生态

const express = require('express');
const bodyParser = require('body-parser');
const cors = require('cors');
const morgan = require('morgan');
const helmet = require('helmet');

const app = express();

// Express 有大量成熟的中间件
app.use(morgan('combined'));        // 日志
app.use(bodyParser.json());         // JSON 解析
app.use(cors());                    // CORS 支持
app.use(helmet());                  // 安全头
app.use(express.static('public'));  // 静态文件

app.listen(3000);

Koa - 更现代但生态相对较小

const Koa = require('koa');
const json = require('koa-json');
const cors = require('@koa/cors');
const logger = require('koa-logger');
const helmet = require('koa-helmet');

const app = new Koa();

// Koa 中间件通常更现代
app.use(logger());                  // 日志
app.use(json());                    // JSON 格式化
app.use(cors());                    // CORS 支持
app.use(helmet());                  // 安全头
app.use(require('koa-static')('public')); // 静态文件

app.listen(3000);

8. 性能对比

基准测试示例

// Express 基准测试
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World');
});

// Koa 基准测试
const Koa = require('koa');
const koaApp = new Koa();

koaApp.use(async (ctx) => {
  ctx.body = 'Hello World';
});

// 通常 Koa 性能更好，因为：
// 1. 更少的中间件开销
// 2. 更现代的异步处理
// 3. 更少的对象封装

9. 学习曲线

Express - 学习曲线平缓

// Express 对初学者更友好
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World');
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Koa - 需要理解现代 JS 特性

// Koa 需要理解 async/await 和洋葱模型
const Koa = require('koa');
const app = new Koa();

app.use(async (ctx, next) => {
  console.log('Request started');
  await next();
  console.log('Request ended');
});

app.use(ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

10. 适用场景对比

Express 适用场景

  1. 快速原型开发 - 丰富的中间件和文档
  2. 传统项目迁移 - 兼容性好
  3. 大型项目 - 成熟的生态系统
  4. 团队协作 - 学习成本低

Koa 适用场景

  1. 现代 Web 应用 - 利用最新 JS 特性
  2. 微服务架构 - 轻量级，性能好
  3. 对性能要求高 - 更好的基准性能
  4. 需要灵活中间件控制 - 洋葱模型提供更好的控制

总结对比表

特性ExpressKoa
发布时间2010年2013年
异步处理回调/Promiseasync/await 原生支持
中间件模型线性模型洋葱模型
请求/响应对象req, res 分离ctx 统一对象
错误处理专门的错误中间件try/catch
路由内置需要额外包
生态系统非常丰富相对较小但现代
学习曲线平缓需要现代 JS 知识
性能良好更好
适用场景通用，适合大多数项目现代应用，微服务

选择哪个框架主要取决于项目需求、团队技能和具体场景。Express 更适合快速开发和团队协作，而 Koa 更适合追求性能和现代开发体验的项目。

默认页脚
Copyright © 2026 pax