Express 中如何定义路由处理函数？-JavaScript中文网-JavaScript教程资源分享门户

本题详细解读

在 Express 中，路由处理函数是用于处理特定 HTTP 请求（如 GET、POST、PUT、DELETE 等）的函数。每个路由处理函数通常接收两个参数：req（请求对象）和 res（响应对象）。

req 对象：包含了客户端请求的所有信息，如请求参数、请求头、请求体等。
res 对象：用于向客户端发送响应，可以通过 res.send()、res.json() 等方法发送响应数据。

1. 定义 GET 请求的路由处理函数

app.get('/example', (req, res) => {
  res.send('This is a GET request');
});

app.get() 用于处理 GET 请求。
第一个参数是路由路径（如 /example），第二个参数是处理函数。

2. 定义 POST 请求的路由处理函数

app.post('/example', (req, res) => {
  res.send('This is a POST request');
});

app.post() 用于处理 POST 请求。
与 GET 请求类似，第一个参数是路由路径，第二个参数是处理函数。

3. 定义 PUT 请求的路由处理函数

app.put('/example', (req, res) => {
  res.send('This is a PUT request');
});

app.put() 用于处理 PUT 请求。
PUT 请求通常用于更新资源。

4. 定义 DELETE 请求的路由处理函数

app.delete('/example', (req, res) => {
  res.send('This is a DELETE request');
});

app.delete() 用于处理 DELETE 请求。
DELETE 请求通常用于删除资源。

5. 处理多个 HTTP 方法

如果需要处理多个 HTTP 方法，可以使用 app.all()：

app.all('/example', (req, res) => {
  res.send('This handles all HTTP methods');
});

app.all() 会匹配所有 HTTP 方法（GET、POST、PUT、DELETE 等）。

6. 使用路由参数

路由处理函数还可以处理动态路由参数：

app.get('/users/:userId', (req, res) => {
  const userId = req.params.userId;
  res.send(`User ID is ${userId}`);
});

:userId 是一个路由参数，可以通过 req.params.userId 获取。

7. 链式路由处理

Express 支持链式路由处理，可以在一个路由上定义多个处理函数：

app.route('/example')
  .get((req, res) => {
    res.send('GET request');
  })
  .post((req, res) => {
    res.send('POST request');
  });

app.route() 允许在一个路由上定义多个 HTTP 方法的处理函数。

8. 使用中间件

路由处理函数还可以使用中间件：

app.use('/example', (req, res, next) => {
  console.log('Middleware executed');
  next();
});

app.get('/example', (req, res) => {
  res.send('GET request with middleware');
});

app.use() 用于定义中间件，中间件函数会在路由处理函数之前执行。

9. 错误处理

可以在路由处理函数中处理错误：

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

app.use((err, req, res, next) => {
  res.status(500).send('Error: ' + err.message);
});

通过 next(err) 将错误传递给错误处理中间件。

10. 异步路由处理

路由处理函数可以是异步的：

app.get('/example', async (req, res) => {
  const data = await fetchData();
  res.send(data);
});

使用 async/await 处理异步操作。

11. 路由模块化

可以将路由处理函数模块化：

// www.javascriptcn.com code example
// routes/example.js
const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
  res.send('GET request');
});

module.exports = router;

// app.js
const express = require('express');
const app = express();
const exampleRouter = require('./routes/example');

app.use('/example', exampleRouter);

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

使用 express.Router() 创建模块化路由，然后在主应用中挂载路由。

12. 路由前缀

可以为路由添加前缀：

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

所有 /example 路由都会以 /api/example 为前缀。

13. 路由参数验证

可以使用中间件验证路由参数：

// www.javascriptcn.com code example
app.param('userId', (req, res, next, userId) => {
  if (!isValidUserId(userId)) {
    return res.status(400).send('Invalid user ID');
  }
  next();
});

app.get('/users/:userId', (req, res) => {
  res.send(`User ID is ${req.params.userId}`);
});

app.param() 用于验证路由参数。

14. 路由缓存

可以使用缓存中间件优化路由性能：

const cache = require('express-cache-middleware');
const cacheMiddleware = new cache();

cacheMiddleware.attach(app);

app.get('/example', (req, res) => {
  res.send('This response is cached');
});

使用 express-cache-middleware 缓存路由响应。

15. 路由日志

可以使用日志中间件记录路由请求：

const morgan = require('morgan');

app.use(morgan('combined'));

app.get('/example', (req, res) => {
  res.send('GET request');
});

使用 morgan 记录路由请求日志。

16. 路由安全

可以使用安全中间件保护路由：

const helmet = require('helmet');

app.use(helmet());

app.get('/example', (req, res) => {
  res.send('Secure GET request');
});

使用 helmet 增强路由安全性。

17. 路由限流

可以使用限流中间件限制路由请求频率：

// www.javascriptcn.com code example
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100 // limit each IP to 100 requests per windowMs
});

app.use(limiter);

app.get('/example', (req, res) => {
  res.send('GET request with rate limiting');
});

使用 express-rate-limit 限制路由请求频率。

18. 路由跨域

可以使用 CORS 中间件处理跨域请求：

const cors = require('cors');

app.use(cors());

app.get('/example', (req, res) => {
  res.send('GET request with CORS');
});

使用 cors 处理跨域请求。

19. 路由压缩

可以使用压缩中间件压缩路由响应：

const compression = require('compression');

app.use(compression());

app.get('/example', (req, res) => {
  res.send('GET request with compression');
});

使用 compression 压缩路由响应。

20. 路由重定向

可以使用 res.redirect() 重定向路由：

app.get('/old-route', (req, res) => {
  res.redirect('/new-route');
});

app.get('/new-route', (req, res) => {
  res.send('This is the new route');
});

使用 res.redirect() 重定向到另一个路由。

21. 路由静态文件

可以使用 express.static() 提供静态文件：

app.use(express.static('public'));

app.get('/example', (req, res) => {
  res.send('GET request with static files');
});

使用 express.static() 提供静态文件服务。

22. 路由模板引擎

可以使用模板引擎渲染路由视图：

app.set('view engine', 'pug');

app.get('/example', (req, res) => {
  res.render('example', { title: 'Example' });
});

使用模板引擎（如 pug）渲染路由视图。

23. 路由文件上传

可以使用 multer 处理文件上传：

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  res.send('File uploaded');
});

使用 multer 处理文件上传。

24. 路由 WebSocket

可以使用 express-ws 处理 WebSocket 请求：

const expressWs = require('express-ws')(app);

app.ws('/example', (ws, req) => {
  ws.on('message', (msg) => {
    ws.send(msg);
  });
});

使用 express-ws 处理 WebSocket 请求。

25. 路由 GraphQL

可以使用 express-graphql 处理 GraphQL 请求：

// www.javascriptcn.com code example
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const schema = buildSchema(`
  type Query {
    hello: String
  }
`);

const root = {
  hello: () => 'Hello, world!'
};

app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: root,
  graphiql: true
}));

使用 express-graphql 处理 GraphQL 请求。

26. 路由 REST API

可以使用 Express 构建 RESTful API：

app.get('/api/users', (req, res) => {
  res.json([{ id: 1, name: 'John' }]);
});

app.post('/api/users', (req, res) => {
  res.status(201).json({ id: 2, name: 'Jane' });
});

使用 Express 构建 RESTful API。

27. 路由版本控制

可以使用路由版本控制：

app.use('/v1', require('./routes/v1'));
app.use('/v2', require('./routes/v2'));

使用路由前缀实现版本控制。

28. 路由测试

可以使用 supertest 测试路由：

// www.javascriptcn.com code example
const request = require('supertest');
const app = require('../app');

describe('GET /example', () => {
  it('responds with JSON', (done) => {
    request(app)
      .get('/example')
      .expect('Content-Type', /json/)
      .expect(200, done);
  });
});

使用 supertest 测试路由。

29. 路由性能监控

可以使用 express-status-monitor 监控路由性能：

const statusMonitor = require('express-status-monitor');

app.use(statusMonitor());

app.get('/example', (req, res) => {
  res.send('GET request with performance monitoring');
});

使用 express-status-monitor 监控路由性能。

30. 路由文档生成

可以使用 swagger-ui-express 生成路由文档：

const swaggerUi = require('swagger-ui-express');
const swaggerDocument = require('./swagger.json');

app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));

app.get('/example', (req, res) => {
  res.send('GET request with API documentation');
});

使用 swagger-ui-express 生成路由文档。

Express 中如何定义路由处理函数？

推荐答案