Detailed comparison and selection recommendations between Koa and Express frameworks - 面试题

Koa and Express are two popular Node.js web frameworks, each with its own characteristics and applicable scenarios. Understanding their differences helps make the right choice in actual projects.

1. Core design philosophy:

Express:

Built-in extensive features (routing, middleware, template engines, etc.)
Provides out-of-the-box solutions
Uses traditional callback function pattern
Middleware chain calling

Koa:

Minimal core, only provides basic functionality
Extends functionality through middleware
Uses modern async/await pattern
Onion model middleware mechanism

2. Middleware mechanism comparison:

Express middleware:

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');
});

// Execution order: Middleware 1 -> Middleware 2 -> Middleware 1 after

Koa middleware:

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';
});

// Execution order: Middleware 1 before -> Middleware 2 before -> 
// Middleware 2 after -> Middleware 1 after

3. Code style comparison:

Express callback style:

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 style:

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. Request/response handling comparison:

Express:

javascript
app.get('/', (req, res) => {
  // Request info
  const url = req.url;
  const method = req.method;
  const query = req.query;
  const body = req.body;
  
  // Response setting
  res.status(200);
  res.json({ message: 'Hello' });
  // or
  res.send('Hello');
  // or
  res.render('index', { title: 'Hello' });
});

Koa:

javascript
app.get('/', async (ctx) => {
  // Request info
  const url = ctx.url;
  const method = ctx.method;
  const query = ctx.query;
  const body = ctx.request.body;
  
  // Response setting
  ctx.status = 200;
  ctx.body = { message: 'Hello' };
  // or
  ctx.type = 'text/html';
  ctx.body = '<h1>Hello</h1>';
});

5. Error handling comparison:

Express error handling:

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

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

Koa error handling:

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);
  }
});

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

6. Routing functionality comparison:

Express built-in routing:

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 needs routing middleware:

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. Performance comparison:

Express:

Mature and stable, verified by many production environments
Middleware chain calling, relatively lower performance
Callback functions, potential callback hell
Relatively higher memory usage

Koa:

More lightweight, core only about 2KB
async/await, cleaner code
Onion model, more flexible middleware control
Relatively lower memory usage

8. Learning curve comparison:

Express:

Rich documentation, active community
Gentle learning curve
Many tutorials and examples
Suitable for beginners

Koa:

Need to understand async/await
Need to understand onion model
Need to choose appropriate middleware
Suitable for developers with some experience

9. Applicable scenarios comparison:

Express suitable for:

Rapid prototyping
Traditional web applications
Projects needing many built-in features
Team members unfamiliar with async/await
Need stable and mature framework

Koa suitable for:

Modern web applications
Projects needing fine-grained middleware control
Pursuing code simplicity and maintainability
Team familiar with modern JavaScript
Need better error handling

10. Migration suggestions:

Migrating from Express to 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;
});

Summary:

Feature	Express	Koa
Core size	Larger	Minimal (2KB)
Middleware pattern	Chain calling	Onion model
Async handling	Callback functions	async/await
Routing	Built-in	Needs middleware
Learning curve	Gentle	Steeper
Community ecosystem	Mature	Fast growing
Performance	Good	Excellent
Applicable scenarios	Traditional apps	Modern apps

Selection recommendations:

If pursuing rapid development and stability, choose Express
If pursuing code quality and modernization, choose Koa
If team familiar with async/await, prioritize Koa
If need many built-in features, choose Express