面试题手册

Jest 的 Mock 功能是测试中隔离依赖和验证行为的重要工具：1. 创建 Mock 函数：const mockFn = jest.fn();mockFn('arg1', 'arg2');expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2');expect(mockFn).toHaveBeenCalledTimes(1);2. Mock 返回值：const mockFn = jest.fn();mockFn.mockReturnValue(42);mockFn.mockReturnValueOnce(10).mockReturnValueOnce(20);// 或使用 mockResolvedValue 处理 PromisemockFn.mockResolvedValue('data');3. Mock 实现：const mockFn = jest.fn((a, b) => a + b);// 或使用 mockImplementationmockFn.mockImplementation((a, b) => a * b);4. Mock 模块：jest.mock('./api', () => ({ fetchData: jest.fn(() => Promise.resolve('data'))}));import { fetchData } from './api';5. Spy 函数：const spy = jest.spyOn(object, 'method');spy.mockRestore(); // 恢复原函数常用断言：toHaveBeenCalled()：被调用toHaveBeenCalledWith(...args)：用特定参数调用toHaveBeenCalledTimes(n)：调用次数toHaveReturnedWith(value)：返回特定值toHaveLastReturnedWith(value)：最后一次返回值最佳实践：Mock 外部依赖，不 Mock 被测代码测试完成后清理 Mock使用 jest.clearAllMocks() 清除调用记录使用 jest.restoreAllMocks() 恢复原始实现

Jest 是 Facebook 开发的 JavaScript 测试框架，它具有零配置、内置断言库、快照测试、模拟系统和覆盖率报告等特点。Jest 支持并行测试执行，可以显著提高测试速度。它还提供了强大的 CLI 工具和丰富的 API，使得编写测试变得简单直观。Jest 适用于测试 React 组件、Node.js 应用程序以及各种 JavaScript 项目。核心特性：零配置：开箱即用，无需复杂配置内置断言：提供丰富的断言方法快照测试：轻松捕获组件输出模拟系统：强大的 mock 和 spy 功能并行执行：自动并行运行测试覆盖率报告：内置代码覆盖率统计使用场景：Jest 广泛应用于前端测试，特别是 React 项目的单元测试、集成测试和端到端测试。它也适用于 Node.js 后端服务的测试。

Jest 提供了强大的代码覆盖率报告功能，帮助开发者了解测试覆盖情况：生成覆盖率报告：# 运行测试并生成覆盖率报告jest --coverage# 或在 package.json 中配置{ "scripts": { "test:coverage": "jest --coverage" }}覆盖率指标：Statements（语句覆盖率）：被执行的代码语句百分比Branches（分支覆盖率）：被执行的条件分支百分比Functions（函数覆盖率）：被调用的函数百分比Lines（行覆盖率）：被执行的代码行百分比配置覆盖率：// jest.config.jsmodule.exports = { collectCoverage: true, collectCoverageFrom: [ 'src/**/*.{js,jsx,ts,tsx}', '!src/**/*.d.ts', '!src/**/*.stories.{js,jsx,ts,tsx}', '!src/index.{js,jsx,ts,tsx}' ], coverageThreshold: { global: { branches: 80, functions: 80, lines: 80, statements: 80 } }, coverageReporters: ['text', 'lcov', 'html']};覆盖率报告格式：text：命令行文本输出lcov：生成 lcov.info 文件，用于 CI/CD 工具html：生成 HTML 报告，可视化查看json：JSON 格式报告最佳实践：设置合理的覆盖率阈值（通常 80%）排除不需要测试的文件（配置文件、类型定义等）在 CI/CD 中集成覆盖率检查定期审查未覆盖的代码关注核心业务逻辑的覆盖率

Jest 提供了多种配置方式来定制测试行为：1. package.json 配置：{ "jest": { "testEnvironment": "node", "coverageThreshold": { "global": { "branches": 80, "functions": 80, "lines": 80, "statements": 80 } } }}2. jest.config.js 配置文件：module.exports = { testEnvironment: 'jsdom', setupFilesAfterEnv: ['<rootDir>/jest.setup.js'], moduleNameMapper: { '^@/(.*)$': '<rootDir>/src/$1', '\\.(css|less|scss)$': 'identity-obj-proxy' }, collectCoverageFrom: [ 'src/**/*.{js,jsx,ts,tsx}', '!src/**/*.d.ts', '!src/**/*.stories.{js,jsx,ts,tsx}' ], testMatch: [ '**/__tests__/**/*.{js,jsx,ts,tsx}', '**/*.{spec,test}.{js,jsx,ts,tsx}' ], transform: { '^.+\\.(js|jsx|ts|tsx)$': 'babel-jest' }};常用配置选项：testEnvironment：测试环境（node、jsdom）setupFilesAfterEnv：测试环境设置文件moduleNameMapper：模块路径映射collectCoverageFrom：覆盖率收集范围testMatch：测试文件匹配模式transform：文件转换配置coverageThreshold：覆盖率阈值testTimeout：测试超时时间命令行选项：jest --watch：监听模式jest --coverage：生成覆盖率报告jest --updateSnapshot：更新快照jest --verbose：详细输出

Jest 提供了多种运行测试和调试测试的方法：运行测试：# 运行所有测试jest# 运行特定文件jest path/to/test.spec.js# 运行匹配模式的测试jest --testNamePattern="should add"# 监听模式（文件变化时自动运行）jest --watch# 只运行失败的测试jest --onlyFailures# 运行修改过的文件相关测试jest --onlyChanged调试测试：1. 使用 console.log：test('debug example', () => { const result = calculate(2, 3); console.log('Result:', result); expect(result).toBe(5);});2. 使用 --verbose 选项：jest --verbose3. 使用 --no-coverage 禁用覆盖率：jest --no-coverage4. 在测试中设置断点：test('debug with debugger', () => { debugger; // 在浏览器或 IDE 中设置断点 const result = calculate(2, 3); expect(result).toBe(5);});5. 使用 Jest 的调试模式：# Node.js 调试node --inspect-brk node_modules/.bin/jest --runInBand# VSCode 调试配置{ "type": "node", "request": "launch", "name": "Jest Current File", "program": "${workspaceFolder}/node_modules/.bin/jest", "args": ["${fileBasenameNoExtension}", "--runInBand"], "console": "integratedTerminal", "internalConsoleOptions": "neverOpen"}常用选项：--runInBand：顺序运行测试（用于调试）--detectOpenHandles：检测未关闭的句柄--forceExit：强制退出--bail：第一个测试失败后停止

Jest 提供了多种跳过和隔离测试的方法，用于在开发过程中专注于特定测试：1. 跳过单个测试：test.skip('this test is skipped', () => { expect(true).toBe(false);});// 或使用 xtestxtest('this test is also skipped', () => { expect(true).toBe(false);});2. 跳过测试套件：describe.skip('skipped suite', () => { test('this test will not run', () => { expect(true).toBe(false); });});// 或使用 xdescribexdescribe('also skipped suite', () => { test('this test will not run', () => { expect(true).toBe(false); });});3. 只运行特定测试：test.only('only this test runs', () => { expect(true).toBe(true);});test('this test is skipped', () => { expect(true).toBe(false);});// 或使用 fitfit('only this test runs', () => { expect(true).toBe(true);});4. 只运行特定测试套件：describe.only('only this suite runs', () => { test('this test runs', () => { expect(true).toBe(true); });});describe('this suite is skipped', () => { test('this test is skipped', () => { expect(true).toBe(false); });});// 或使用 fdescribefdescribe('only this suite runs', () => { test('this test runs', () => { expect(true).toBe(true); });});5. 条件性跳过测试：const skipIf = (condition, testName, testFn) => { const testOrSkip = condition ? test.skip : test; testOrSkip(testName, testFn);};skipIf(process.env.CI, 'skip in CI', () => { expect(true).toBe(true);});6. 使用命令行过滤测试：# 只运行匹配模式的测试jest --testNamePattern="should add"# 只运行特定文件jest path/to/test.spec.js# 只运行修改过的文件相关测试jest --onlyChanged最佳实践：使用 .only 进行调试，完成后移除使用 .skip 暂时禁用失败的测试避免提交包含 .only 或 .skip 的代码使用命令行选项进行临时测试过滤在 CI/CD 中使用 --onlyFailures 只运行失败的测试

Jest 提供了多种测试异步代码的方法：1. 使用回调函数：test('async callback', (done) => { fetchData(callback => { expect(callback).toBe('data'); done(); });});2. 使用 Promise：test('async promise', () => { return fetchData().then(data => { expect(data).toBe('data'); });});// 或者使用 async/awaittest('async await', async () => { const data = await fetchData(); expect(data).toBe('data');});3. 使用 resolves 和 rejects：test('promise resolves', () => { return expect(fetchData()).resolves.toBe('data');});test('promise rejects', () => { return expect(fetchData()).rejects.toThrow('error');});4. 测试定时器：jest.useFakeTimers();test('timer callback', () => { const callback = jest.fn(); setTimeout(callback, 1000); jest.runAllTimers(); expect(callback).toHaveBeenCalled();});最佳实践：优先使用 async/await，代码更清晰确保返回 Promise 或调用 done使用 resolves 和 rejects 简化断言测试定时器时使用 jest.useFakeTimers()设置合理的超时时间（默认 5 秒）

Koa 的性能优化是构建高性能应用的关键。通过合理配置和优化策略，可以显著提升应用的响应速度和并发处理能力。1. 中间件优化：减少中间件数量：// 不好的做法：过多的中间件app.use(middleware1);app.use(middleware2);app.use(middleware3);app.use(middleware4);app.use(middleware5);// 好的做法：合并功能相似的中间件app.use(compose([middleware1, middleware2]));app.use(compose([middleware3, middleware4]));优化中间件顺序：// 将高频使用的中间件放在前面app.use(loggerMiddleware); // 日志app.use(corsMiddleware); // CORSapp.use(bodyParserMiddleware); // 解析请求体app.use(authMiddleware); // 认证app.use(routerMiddleware); // 路由避免在中间件中执行耗时操作：// 不好的做法：在中间件中执行数据库查询app.use(async (ctx, next) => { const user = await User.findById(ctx.session.userId); ctx.state.user = user; await next();});// 好的做法：按需加载数据app.use(async (ctx, next) => { await next(); // 在需要时再加载数据});2. 异步处理优化：使用 Promise.all 并行处理：// 不好的做法：串行执行app.use(async (ctx) => { const user = await User.findById(id); const posts = await Post.findByUserId(id); const comments = await Comment.findByUserId(id); ctx.body = { user, posts, comments };});// 好的做法：并行执行app.use(async (ctx) => { const [user, posts, comments] = await Promise.all([ User.findById(id), Post.findByUserId(id), Comment.findByUserId(id) ]); ctx.body = { user, posts, comments };});使用缓存减少重复查询：const cache = new Map();app.use(async (ctx) => { const cacheKey = `user:${ctx.params.id}`; // 检查缓存 if (cache.has(cacheKey)) { ctx.body = cache.get(cacheKey); return; } // 查询数据库 const user = await User.findById(ctx.params.id); cache.set(cacheKey, user); ctx.body = user;});3. 数据库连接池优化：const { Pool } = require('pg');// 配置连接池const pool = new Pool({ host: 'localhost', port: 5432, database: 'mydb', user: 'user', password: 'password', max: 20, // 最大连接数 min: 5, // 最小连接数 idleTimeoutMillis: 30000, connectionTimeoutMillis: 2000});app.use(async (ctx, next) => { const client = await pool.connect(); ctx.state.db = client; try { await next(); } finally { client.release(); }});4. 响应压缩：使用 koa-compress 中间件压缩响应。npm install koa-compressconst compress = require('koa-compress');app.use(compress({ filter: (contentType) => { return /text/i.test(contentType); }, threshold: 2048, // 大于 2KB 时压缩 gzip: { flush: require('zlib').constants.Z_SYNC_FLUSH }, deflate: { flush: require('zlib').constants.Z_SYNC_FLUSH }, br: false // 禁用 brotli}));5. 静态资源优化：const serve = require('koa-static');const { createGzip } = require('zlib');const { createReadStream, createWriteStream } = require('fs');// 配置静态资源服务app.use(serve('./public', { maxage: 365 * 24 * 60 * 60 * 1000, // 1 年缓存 gzip: true, brotli: true}));// 预压缩静态资源function precompressStaticFiles() { const files = fs.readdirSync('./public'); files.forEach(file => { if (file.endsWith('.js') || file.endsWith('.css')) { const filePath = path.join('./public', file); const gzipPath = filePath + '.gz'; const readStream = createReadStream(filePath); const writeStream = createWriteStream(gzipPath); const gzip = createGzip(); readStream.pipe(gzip).pipe(writeStream); } });}6. HTTP/2 支持：const http2 = require('http2');const fs = require('fs');const server = http2.createSecureServer({ key: fs.readFileSync('server.key'), cert: fs.readFileSync('server.crt')}, app.callback());server.listen(3000);7. 集群模式：使用 Node.js 的 cluster 模块充分利用多核 CPU。const cluster = require('cluster');const numCPUs = require('os').cpus().length;if (cluster.isMaster) { console.log(`Master ${process.pid} is running`); for (let i = 0; i < numCPUs; i++) { cluster.fork(); } cluster.on('exit', (worker, code, signal) => { console.log(`Worker ${worker.process.pid} died`); cluster.fork(); });} else { app.listen(3000); console.log(`Worker ${process.pid} started`);}8. 监控和性能分析：const prometheus = require('prom-client');// 创建指标const httpRequestDuration = new prometheus.Histogram({ name: 'http_request_duration_seconds', help: 'Duration of HTTP requests in seconds', labelNames: ['method', 'route', 'code']});// 中间件收集指标app.use(async (ctx, next) => { const start = Date.now(); await next(); const duration = (Date.now() - start) / 1000; httpRequestDuration.observe( { method: ctx.method, route: ctx.path, code: ctx.status }, duration );});// 指标端点app.use(async (ctx) => { if (ctx.path === '/metrics') { ctx.set('Content-Type', prometheus.register.contentType); ctx.body = await prometheus.register.metrics(); }});9. 代码分割和懒加载：// 懒加载路由app.use(async (ctx, next) => { if (ctx.path.startsWith('/admin')) { const adminRoutes = await import('./routes/admin'); adminRoutes.default.routes()(ctx, next); } else if (ctx.path.startsWith('/api')) { const apiRoutes = await import('./routes/api'); apiRoutes.default.routes()(ctx, next); } else { await next(); }});10. 性能优化最佳实践：中间件优化：减少中间件数量合并功能相似的中间件优化中间件执行顺序避免在中间件中执行耗时操作异步处理：使用 Promise.all 并行处理实现缓存机制使用连接池管理数据库连接避免阻塞主线程资源优化：压缩响应内容启用静态资源缓存使用 CDN 加速预压缩静态资源架构优化：使用集群模式实现负载均衡使用 HTTP/2实现微服务架构监控和调优：实现性能监控使用性能分析工具定期进行性能测试持续优化和改进

Koa 测试是保证应用质量的重要环节。通过合理的测试策略和工具，可以确保应用的稳定性和可靠性。1. 测试框架选择：常用的 Koa 测试框架包括：Jest：Facebook 开发的测试框架，功能全面Mocha + Chai：灵活的测试框架组合Supertest：专门用于 HTTP 测试的库2. 基本测试设置：安装依赖：npm install --save-dev jest supertest @types/jest @types/supertestJest 配置：// jest.config.jsmodule.exports = { testEnvironment: 'node', coverageDirectory: 'coverage', collectCoverageFrom: [ 'src/**/*.js', '!src/**/*.test.js' ], testMatch: [ '**/__tests__/**/*.js', '**/?(*.)+(spec|test).js' ]};3. 基本路由测试：const request = require('supertest');const app = require('../app');describe('Basic routes', () => { test('GET / should return Hello Koa', async () => { const response = await request(app.callback()) .get('/') .expect(200); expect(response.text).toBe('Hello Koa'); }); test('GET /not-found should return 404', async () => { const response = await request(app.callback()) .get('/not-found') .expect(404); });});4. 中间件测试：const Koa = require('koa');const loggerMiddleware = require('../middleware/logger');describe('Logger middleware', () => { test('should log request information', async () => { const app = new Koa(); const logs = []; // Mock console.log const originalLog = console.log; console.log = (...args) => logs.push(args.join(' ')); app.use(loggerMiddleware); app.use(async (ctx) => { ctx.body = 'test'; }); await request(app.callback()).get('/test'); console.log = originalLog; expect(logs.length).toBeGreaterThan(0); expect(logs[0]).toContain('GET /test'); });});5. 认证中间件测试：const authMiddleware = require('../middleware/auth');describe('Auth middleware', () => { test('should allow access with valid token', async () => { const ctx = { headers: { authorization: 'Bearer valid-token' }, state: {} }; const next = jest.fn(); await authMiddleware(ctx, next); expect(next).toHaveBeenCalled(); expect(ctx.state.user).toBeDefined(); }); test('should deny access without token', async () => { const ctx = { headers: {}, state: {}, throw: jest.fn() }; const next = jest.fn(); await authMiddleware(ctx, next); expect(next).not.toHaveBeenCalled(); expect(ctx.throw).toHaveBeenCalledWith(401, 'Unauthorized'); });});6. API 测试：describe('User API', () => { test('POST /api/users should create user', async () => { const userData = { name: 'John Doe', email: 'john@example.com', password: 'password123' }; const response = await request(app.callback()) .post('/api/users') .send(userData) .expect(201); expect(response.body).toHaveProperty('id'); expect(response.body.name).toBe(userData.name); expect(response.body.email).toBe(userData.email); expect(response.body).not.toHaveProperty('password'); }); test('GET /api/users/:id should return user', async () => { const userId = 1; const response = await request(app.callback()) .get(`/api/users/${userId}`) .expect(200); expect(response.body).toHaveProperty('id', userId); expect(response.body).toHaveProperty('name'); expect(response.body).toHaveProperty('email'); }); test('PUT /api/users/:id should update user', async () => { const userId = 1; const updateData = { name: 'Updated Name' }; const response = await request(app.callback()) .put(`/api/users/${userId}`) .send(updateData) .expect(200); expect(response.body.name).toBe(updateData.name); }); test('DELETE /api/users/:id should delete user', async () => { const userId = 1; await request(app.callback()) .delete(`/api/users/${userId}`) .expect(204); });});7. 错误处理测试：describe('Error handling', () => { test('should handle 404 errors', async () => { const response = await request(app.callback()) .get('/non-existent-route') .expect(404); expect(response.body).toHaveProperty('error'); expect(response.body).toHaveProperty('code', 'NOT_FOUND'); }); test('should handle validation errors', async () => { const invalidData = { name: '', email: 'invalid-email' }; const response = await request(app.callback()) .post('/api/users') .send(invalidData) .expect(400); expect(response.body).toHaveProperty('error'); expect(response.body).toHaveProperty('code', 'VALIDATION_ERROR'); }); test('should handle server errors', async () => { // Mock a database error jest.spyOn(User, 'create').mockRejectedValue(new Error('Database error')); const response = await request(app.callback()) .post('/api/users') .send({ name: 'Test', email: 'test@example.com' }) .expect(500); expect(response.body).toHaveProperty('error'); expect(response.body).toHaveProperty('code', 'INTERNAL_ERROR'); });});8. 集成测试：describe('Integration tests', () => { let authToken; beforeAll(async () => { // Setup: create test user and get token const response = await request(app.callback()) .post('/api/auth/login') .send({ email: 'test@example.com', password: 'password123' }); authToken = response.body.token; }); afterAll(async () => { // Cleanup: delete test data await request(app.callback()) .delete('/api/test/cleanup'); }); test('should create and retrieve post', async () => { // Create post const createResponse = await request(app.callback()) .post('/api/posts') .set('Authorization', `Bearer ${authToken}`) .send({ title: 'Test Post', content: 'Test content' }) .expect(201); const postId = createResponse.body.id; // Retrieve post const getResponse = await request(app.callback()) .get(`/api/posts/${postId}`) .expect(200); expect(getResponse.body.title).toBe('Test Post'); expect(getResponse.body.content).toBe('Test content'); });});9. 性能测试：describe('Performance tests', () => { test('should handle 1000 requests in reasonable time', async () => { const startTime = Date.now(); const requests = []; for (let i = 0; i < 1000; i++) { requests.push( request(app.callback()) .get('/api/users') .expect(200) ); } await Promise.all(requests); const duration = Date.now() - startTime; expect(duration).toBeLessThan(5000); // Should complete in < 5 seconds });});10. 测试最佳实践：测试组织：按功能模块组织测试文件使用 describe 分组相关测试使用有意义的测试名称测试隔离：每个测试应该独立运行使用 beforeAll/afterAll 设置和清理使用 beforeEach/afterEach 重置状态Mock 和 Stub：Mock 外部依赖使用测试数据库避免测试真实网络请求覆盖率：设置覆盖率目标（通常 > 80%）定期检查覆盖率报告关注关键路径的覆盖率持续集成：在 CI/CD 流程中运行测试测试失败时阻止部署自动生成覆盖率报告测试数据：使用工厂模式创建测试数据使用固定的测试数据清理测试数据避免污染// 测试数据工厂const userFactory = (overrides = {}) => ({ name: 'Test User', email: 'test@example.com', password: 'password123', ...overrides});// 使用工厂test('should create user', async () => { const userData = userFactory({ name: 'Custom Name' }); const response = await request(app.callback()) .post('/api/users') .send(userData) .expect(201); expect(response.body.name).toBe('Custom Name');});

Koa 核心不包含路由功能，需要通过中间件实现。最常用的路由中间件是 @koa/router，它提供了强大的路由定义和管理功能。安装路由中间件：npm install @koa/router基本路由使用：const Koa = require('koa');const Router = require('@koa/router');const app = new Koa();const router = new Router();// 定义路由router.get('/', async (ctx) => { ctx.body = 'Hello Koa';});router.get('/users/:id', async (ctx) => { const id = ctx.params.id; ctx.body = `User ${id}`;});router.post('/users', async (ctx) => { const user = ctx.request.body; ctx.body = { success: true, user };});// 注册路由中间件app.use(router.routes());app.use(router.allowedMethods());app.listen(3000);路由参数：路径参数：router.get('/users/:id', async (ctx) => { const { id } = ctx.params; ctx.body = `User ID: ${id}`;});// 多个参数router.get('/posts/:postId/comments/:commentId', async (ctx) => { const { postId, commentId } = ctx.params; ctx.body = `Post: ${postId}, Comment: ${commentId}`;});查询参数：router.get('/search', async (ctx) => { const { keyword, page, limit } = ctx.query; ctx.body = { keyword, page, limit };});正则表达式路由：router.get(/^\/users\/(\d+)$/, async (ctx) => { const id = ctx.params[0]; ctx.body = `User ID: ${id}`;});路由方法：router.get('/resource', handler); // GETrouter.post('/resource', handler); // POSTrouter.put('/resource', handler); // PUTrouter.delete('/resource', handler); // DELETErouter.patch('/resource', handler); // PATCHrouter.all('/resource', handler); // 所有方法路由前缀：const apiRouter = new Router({ prefix: '/api/v1'});apiRouter.get('/users', handler); // 实际路径: /api/v1/usersapiRouter.post('/login', handler); // 实际路径: /api/v1/loginapp.use(apiRouter.routes());路由嵌套：const userRouter = new Router({ prefix: '/users'});userRouter.get('/', async (ctx) => { ctx.body = 'User list';});userRouter.get('/:id', async (ctx) => { ctx.body = `User ${ctx.params.id}`;});const commentRouter = new Router({ prefix: '/:userId/comments'});commentRouter.get('/', async (ctx) => { ctx.body = `Comments for user ${ctx.params.userId}`;});userRouter.use(commentRouter.routes());app.use(userRouter.routes());路由中间件：// 单个路由中间件router.get('/protected', authMiddleware, async (ctx) => { ctx.body = 'Protected content';});// 多个路由中间件router.post('/admin', authMiddleware, adminMiddleware, async (ctx) => { ctx.body = 'Admin content'; });// 路由级中间件router.use(async (ctx, next) => { console.log('Router middleware'); await next();});路由分组和模块化：// routes/users.jsconst Router = require('@koa/router');const router = new Router({ prefix: '/users' });router.get('/', async (ctx) => { ctx.body = 'User list';});router.get('/:id', async (ctx) => { ctx.body = `User ${ctx.params.id}`;});module.exports = router;// app.jsconst userRoutes = require('./routes/users');app.use(userRoutes.routes());app.use(userRoutes.allowedMethods());路由命名和重定向：router.get('user', '/users/:id', async (ctx) => { ctx.body = `User ${ctx.params.id}`;});router.redirect('/old-path', '/new-path');router.redirect('/old-path', 'user', { id: 123 });错误处理：router.get('/error', async (ctx) => { ctx.throw(404, 'User not found');});// 使用 allowedMethods 处理不允许的方法app.use(router.allowedMethods({ throw: true, notImplemented: () => new NotImplemented(), methodNotAllowed: () => new MethodNotAllowed()}));最佳实践：按功能模块划分路由文件使用路由前缀组织 API 版本合理使用路由中间件进行权限控制统一错误处理和响应格式为路由添加描述性注释使用 TypeScript 增强类型安全