Koa 与 Express 框架的详细对比和选择建议 - 面试题

Koa 与 Express 是两个流行的 Node.js Web 框架，它们各有特点和适用场景。理解它们的差异有助于在实际项目中做出正确的选择。

1. 核心设计理念：

Express：

内置大量功能（路由、中间件、模板引擎等）
提供开箱即用的解决方案
采用传统的回调函数模式
中间件链式调用

Koa：

极简核心，只提供最基础的功能
通过中间件扩展功能
采用现代 async/await 模式
洋葱模型中间件机制

2. 中间件机制对比：

Express 中间件：

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

app.use((req, res, next) => {
  console.log('Middleware 1');
  next();
  console.log('Middleware 1 after');
});

app.use((req, res, next) => {
  console.log('Middleware 2');
  res.send('Hello Express');
});

// 执行顺序：Middleware 1 -> Middleware 2 -> Middleware 1 after

Koa 中间件：

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

app.use(async (ctx, next) => {
  console.log('Middleware 1 before');
  await next();
  console.log('Middleware 1 after');
});

app.use(async (ctx, next) => {
  console.log('Middleware 2 before');
  await next();
  console.log('Middleware 2 after');
  ctx.body = 'Hello Koa';
});

// 执行顺序：Middleware 1 before -> Middleware 2 before -> 
// Middleware 2 after -> Middleware 1 after

3. 代码风格对比：

Express 回调风格：

javascript
app.get('/users/:id', (req, res, next) => {
  User.findById(req.params.id, (err, user) => {
    if (err) return next(err);
    
    Post.findByUserId(user.id, (err, posts) => {
      if (err) return next(err);
      
      res.json({ user, posts });
    });
  });
});

Koa async/await 风格：

javascript
app.get('/users/:id', async (ctx) => {
  const user = await User.findById(ctx.params.id);
  const posts = await Post.findByUserId(user.id);
  ctx.body = { user, posts };
});

4. 请求/响应处理对比：

Express：

javascript
app.get('/', (req, res) => {
  // 请求信息
  const url = req.url;
  const method = req.method;
  const query = req.query;
  const body = req.body;
  
  // 响应设置
  res.status(200);
  res.json({ message: 'Hello' });
  // 或
  res.send('Hello');
  // 或
  res.render('index', { title: 'Hello' });
});

Koa：

javascript
app.get('/', async (ctx) => {
  // 请求信息
  const url = ctx.url;
  const method = ctx.method;
  const query = ctx.query;
  const body = ctx.request.body;
  
  // 响应设置
  ctx.status = 200;
  ctx.body = { message: 'Hello' };
  // 或
  ctx.type = 'text/html';
  ctx.body = '<h1>Hello</h1>';
});

5. 错误处理对比：

Express 错误处理：

javascript
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({
    error: err.message
  });
});

// 抛出错误
app.get('/error', (req, res, next) => {
  const err = new Error('Something went wrong');
  err.status = 500;
  next(err);
});

Koa 错误处理：

javascript
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.status = err.status || 500;
    ctx.body = {
      error: err.message
    };
    ctx.app.emit('error', err, ctx);
  }
});

// 抛出错误
app.get('/error', async (ctx) => {
  ctx.throw(500, 'Something went wrong');
});

6. 路由功能对比：

Express 内置路由：

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

router.get('/users', getUsers);
router.post('/users', createUser);
router.get('/users/:id', getUser);
router.put('/users/:id', updateUser);
router.delete('/users/:id', deleteUser);

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

Koa 需要路由中间件：

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

router.get('/users', getUsers);
router.post('/users', createUser);
router.get('/users/:id', getUser);
router.put('/users/:id', updateUser);
router.delete('/users/:id', deleteUser);

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

7. 性能对比：

Express：

成熟稳定，经过大量生产环境验证
中间件链式调用，性能相对较低
回调函数，可能存在回调地狱
内存占用相对较高

Koa：

更轻量级，核心只有约 2KB
async/await，代码更简洁
洋葱模型，中间件控制更灵活
内存占用相对较低

8. 学习曲线对比：

Express：

文档丰富，社区活跃
学习曲线平缓
大量教程和示例
适合初学者

Koa：

需要理解 async/await
需要理解洋葱模型
需要选择合适的中间件
适合有一定经验的开发者

9. 适用场景对比：

Express 适合：

快速开发原型
传统 Web 应用
需要大量内置功能的项目
团队成员对 async/await 不熟悉
需要稳定成熟的框架

Koa 适合：

现代 Web 应用
需要精细控制中间件的项目
追求代码简洁和可维护性
团队熟悉现代 JavaScript
需要更好的错误处理

10. 迁移建议：

从 Express 迁移到 Koa：

javascript
// Express
app.get('/users/:id', async (req, res, next) => {
  try {
    const user = await User.findById(req.params.id);
    res.json(user);
  } catch (err) {
    next(err);
  }
});

// Koa
app.get('/users/:id', async (ctx) => {
  const user = await User.findById(ctx.params.id);
  ctx.body = user;
});

总结：

特性	Express	Koa
核心大小	较大	极小（2KB）
中间件模式	链式调用	洋葱模型
异步处理	回调函数	async/await
路由	内置	需要中间件
学习曲线	平缓	较陡
社区生态	成熟	快速发展
性能	良好	优秀
适用场景	传统应用	现代应用

选择建议：

如果追求快速开发和稳定性，选择 Express
如果追求代码质量和现代化，选择 Koa
如果团队熟悉 async/await，优先选择 Koa
如果需要大量内置功能，选择 Express