1
// 引入 Express
2
const express = require('express');
3

4
// 创建应用
5
const app = express();
6

7
// 定义路由：访问首页时返回"Hello, Express!"
8
app.get('/', (req, res) => {
9
  res.send('Hello, Express! 🎉');
10
});
11

12
// 启动服务器
13
app.listen(3000, () => {
14
  console.log('✅ 服务器已启动！访问 http://localhost:3000');
15
});

1
Hello, Express! 🎉

1
原材料 → [工位1：检查材料] → [工位2：组装零件] → [工位3：喷漆] → [工位4：质检] → 成品

1
用户请求 → [中间件1：记录日志] → [中间件2：解析数据] → [中间件3：验证身份] → [路由处理器] → 响应

1
水 → [粗网：过滤大颗粒] → [细网：过滤小颗粒] → [活性炭：吸附杂质] → [消毒：杀菌] → 干净水

1
请求 → [日志中间件] → [解析中间件] → [验证中间件] → [路由处理器] → 响应

1
// 使用有意义的标签
2
console.log('[用户服务] 查询用户 ID:', userId);
3
console.log('[数据库] 连接成功');
4

5
// 使用对象展开
6
console.log('请求数据:', { ...req.body });
7

8
// 使用时间戳
9
console.log(`[${new Date().toISOString()}] 处理请求: ${req.method} ${req.url}`);

1
// 没有标签
2
console.log(userId);
3

4
// 输出过多信息
5
console.log(req);  // 会输出整个请求对象，非常混乱
6

7
// 忘记删除调试代码
8
console.log('调试信息');  // 生产环境不应该有

1
{
2
  "version": "0.2.0",
3
  "configurations": [
4
    {
5
      "type": "node",
6
      "request": "launch",
7
      "name": "启动 Express 应用",
8
      "program": "${workspaceFolder}/app.js",
9
      "skipFiles": [
10
        "<node_internals>/**"
11
      ]
12
    }
13
  ]
14
}

1
const morgan = require('morgan');
2

3
// 开发环境：详细日志
4
if (process.env.NODE_ENV === 'development') {
5
  app.use(morgan('dev'));
6
}
7

8
// 生产环境：简洁日志
9
if (process.env.NODE_ENV === 'production') {
10
  app.use(morgan('combined'));
11
}
12

13
// 自定义日志格式
14
app.use(morgan(':method :url :status :res[content-length] - :response-time ms'));

1
const debug = require('debug')('myapp:server');
2
const debugUser = require('debug')('myapp:user');
3

4
app.get('/api/users/:id', async (req, res) => {
5
  debug('收到用户查询请求');
6

7
  const userId = req.params.id;
8
  debugUser('查询用户 ID: %s', userId);
9

10
  try {
11
    const user = await User.findById(userId);
12
    debugUser('查询结果: %O', user);
13

14
    if (!user) {
15
      debug('用户不存在');
16
      return res.status(404).json({ error: '用户不存在' });
17
    }
18

19
    res.json(user);
20
  } catch (error) {
21
    debug('查询错误: %O', error);
22
    res.status(500).json({ error: '服务器错误' });
23
  }
24
});

1
Error: listen EADDRINUSE: address already in use :::3000

1
const PORT = process.env.PORT || 3001;  // 改用 3001

1
const detectPort = require('detect-port');
2

3
detectPort(3000).then(port => {
4
  if (port === 3000) {
5
    console.log('端口 3000 可用');
6
  } else {
7
    console.log(`端口 3000 被占用，使用端口 ${port}`);
8
  }
9

10
  app.listen(port, () => {
11
    console.log(`服务器运行在端口 ${port}`);
12
  });
13
});

1
// ❌ 错误：通配路由放前面
2
app.get('/api/users/*', (req, res) => {
3
  res.send('所有用户');
4
});
5

6
app.get('/api/users/admin', (req, res) => {
7
  res.send('管理员');  // 永远不会执行
8
});
9

10
// ✅ 正确：具体路由放前面
11
app.get('/api/users/admin', (req, res) => {
12
  res.send('管理员');
13
});
14

15
app.get('/api/users/*', (req, res) => {
16
  res.send('所有用户');
17
});

1
// ❌ 错误：路由在静态文件中间件之前
2
app.get('/index.html', (req, res) => {
3
  res.send('自定义首页');
4
});
5

6
app.use(express.static('public'));  // 会先匹配静态文件
7

8
// ✅ 正确：静态文件中间件在前
9
app.use(express.static('public'));
10

11
app.get('/index.html', (req, res) => {
12
  res.send('自定义首页');  // 只有找不到静态文件时才会执行
13
});

1
// 路由定义
2
app.get('/api/Users', (req, res) => {
3
  res.send('用户列表');
4
});
5

6
// ❌ 错误：大小写不匹配
7
// 访问：/api/users  （返回 404）
8

9
// ✅ 正确：大小写匹配
10
// 访问：/api/Users

1
// ✅ 添加解析中间件
2
app.use(express.json());  // 解析 JSON
3
app.use(express.urlencoded({ extended: true }));  // 解析 URL 编码
4

5
app.post('/api/users', (req, res) => {
6
  console.log(req.body);  // 现在可以正确获取请求体
7
  res.json(req.body);
8
});

1
Access to XMLHttpRequest at 'http://localhost:3000/api/users'
2
from origin 'http://localhost:8080' has been blocked by CORS policy

1
const cors = require('cors');
2

3
// 允许所有来源（开发环境）
4
app.use(cors());
5

6
// 只允许特定来源（生产环境）
7
app.use(cors({
8
  origin: 'https://yourdomain.com'
9
}));
10

11
// 允许多个来源
12
app.use(cors({
13
  origin: ['https://example1.com', 'https://example2.com']
14
}));
15

16
// 自定义 CORS 配置
17
app.use(cors({
18
  origin: function (origin, callback) {
19
    // 允许没有 origin 的请求（如移动应用）
20
    if (!origin) return callback(null, true);
21

22
    if (allowedOrigins.indexOf(origin) === -1) {
23
      const msg = 'CORS policy for this site does not allow access from the specified Origin.';
24
      return callback(new Error(msg), false);
25
    }
26
    return callback(null, true);
27
  }
28
}));

1
app.get('/api/users/:id', async (req, res, next) => {
2
  try {
3
    const user = await User.findById(req.params.id);
4
    res.json(user);
5
  } catch (error) {
6
    next(error);  // 传递给错误处理中间件
7
  }
8
});

1
// 捕获未处理的 Promise 拒绝
2
process.on('unhandledRejection', (reason, promise) => {
3
  console.error('未处理的 Promise 拒绝:', reason);
4
});
5

6
// 捕获未捕获的异常
7
process.on('uncaughtException', (error) => {
8
  console.error('未捕获的异常:', error);
9
  process.exit(1);  // 退出进程
10
});

1
require('express-async-errors');  // 必须在引入 express 之后
2

3
// 现在可以直接使用 async/await，不需要 try-catch
4
app.get('/api/users/:id', async (req, res) => {
5
  const user = await User.findById(req.params.id);
6
  res.json(user);  // 如果出错，会自动传递给错误处理中间件
7
});

1
MongoNetworkError: failed to connect to server [localhost:27017]

1
// ❌ 错误：可能拼写错误
2
mongoose.connect('mongodb://localhost:27017/myapp');
3

4
// ✅ 正确：添加错误处理
5
mongoose.connect('mongodb://localhost:27017/myapp', {
6
  useNewUrlParser: true,
7
  useUnifiedTopology: true
8
})
9
.then(() => console.log('数据库连接成功'))
10
.catch(error => {
11
  console.error('数据库连接失败:', error);
12
  process.exit(1);
13
});

1
// 测试数据库连接
2
const mongoose = require('mongoose');
3

4
mongoose.connection.on('connected', () => {
5
  console.log('MongoDB 连接成功');
6
});
7

8
mongoose.connection.on('error', (error) => {
9
  console.error('MongoDB 连接错误:', error);
10
});
11

12
mongoose.connection.on('disconnected', () => {
13
  console.log('MongoDB 连接断开');
14
});

1
// ❌ 错误：全局变量无限增长
2
const cache = {};
3

4
app.get('/api/data', (req, res) => {
5
  cache[Date.now()] = req.query.data;  // 缓存无限增长
6
  res.json({ success: true });
7
});
8

9
// ✅ 正确：限制缓存大小
10
const cache = new Map();
11
const MAX_CACHE_SIZE = 1000;
12

13
app.get('/api/data', (req, res) => {
14
  if (cache.size >= MAX_CACHE_SIZE) {
15
    // 删除最旧的条目
16
    const oldestKey = cache.keys().next().value;
17
    cache.delete(oldestKey);
18
  }
19

20
  cache.set(Date.now(), req.query.data);
21
  res.json({ success: true });
22
});

1
// ❌ 错误：事件监听器累积
2
app.get('/api/data', (req, res) => {
3
  someEmitter.on('data', handler);  // 每次请求都添加监听器
4
  res.json({ success: true });
5
});
6

7
// ✅ 正确：使用 once 或移除监听器
8
app.get('/api/data', (req, res) => {
9
  someEmitter.once('data', handler);  // 只执行一次
10
  res.json({ success: true });
11
});

1
// ❌ 错误：定时器未清理
2
app.post('/api/schedule', (req, res) => {
3
  setInterval(() => {
4
    // 定时任务
5
  }, 1000);  // 每次请求都创建定时器
6
  res.json({ success: true });
7
});
8

9
// ✅ 正确：清理定时器
10
const timers = new Set();
11

12
app.post('/api/schedule', (req, res) => {
13
  const timer = setInterval(() => {
14
    // 定时任务
15
  }, 1000);
16

17
  timers.add(timer);
18

19
  // 在某个时机清理
20
  // clearInterval(timer);
21
  // timers.delete(timer);
22

23
  res.json({ success: true });
24
});

1
// 在 app.js 中添加
2
const inspector = require('inspector');
3
const fs = require('fs');
4

5
if (process.env.NODE_ENV === 'development') {
6
  inspector.open(9229, '0.0.0.0');
7
  console.log('调试器运行在 http://localhost:9229');
8
}

1
const winston = require('winston');
2

3
const logger = winston.createLogger({
4
  level: 'info',
5
  format: winston.format.json(),
6
  transports: [
7
    // 错误日志
8
    new winston.transports.File({
9
      filename: 'error.log',
10
      level: 'error'
11
    }),
12
    // 所有日志
13
    new winston.transports.File({
14
      filename: 'combined.log'
15
    })
16
  ]
17
});
18

19
// 开发环境同时输出到控制台
20
if (process.env.NODE_ENV !== 'production') {
21
  logger.add(new winston.transports.Console({
22
    format: winston.format.simple()
23
  }));
24
}
25

26
// 使用日志
27
logger.info('服务器启动');
28
logger.error('数据库连接失败', { error: err });
29
logger.warn('内存使用率过高', { usage: '90%' });