// 回调函数
function fetchData(callback) {
    setTimeout(() => {
        const data = { id: 1, name: 'Node.js' };
        callback(null, data);
    }, 1000);
}

fetchData((err, data) => {
    if (err) {
        console.error('Error:', err);
    } else {
        console.log('Data:', data);
    }
});

// Promise
function fetchData() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            const data = { id: 1, name: 'Node.js' };
            resolve(data);
        }, 1000);
    });
}

fetchData()
    .then(data => console.log('Data:', data))
    .catch(err => console.error('Error:', err));

// async/await
async function getData() {
    try {
        const data = await fetchData();
        console.log('Data:', data);
    } catch (err) {
        console.error('Error:', err);
    }
}

getData();

// 创建 Buffer
const buffer1 = Buffer.from('Hello', 'utf8');
const buffer2 = Buffer.alloc(10);
const buffer3 = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f]);

// 读取 Buffer
console.log(buffer1.toString()); // 'Hello'
console.log(buffer1.length); // 5

// Buffer 操作
buffer1.write('World');
console.log(buffer1.toString()); // 'World'

// 可读流
const fs = require('fs');
const readableStream = fs.createReadStream('input.txt');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk);
});

readableStream.on('end', () => {
    console.log('Stream ended');
});

// 可写流
const writableStream = fs.createWriteStream('output.txt');
writableStream.write('Hello, World!');
writableStream.end();

// 管道操作
fs.createReadStream('input.txt')
    .pipe(fs.createWriteStream('output.txt'));

// 文件系统模块
const fs = require('fs');

// HTTP 模块
const http = require('http');

// 路径模块
const path = require('path');

// 事件模块
const EventEmitter = require('events');

// Express.js
const express = require('express');

// Lodash
const _ = require('lodash');

// Moment.js
const moment = require('moment');

// math.js
const add = (a, b) => a + b;
const subtract = (a, b) => a - b;

module.exports = {
    add,
    subtract
};

// app.js
const math = require('./math');
console.log(math.add(5, 3)); // 8
console.log(math.subtract(5, 3)); // 2

// 方式一：exports 导出
exports.add = function(a, b) {
    return a + b;
};

exports.subtract = function(a, b) {
    return a - b;
};

// 方式二：module.exports 导出
module.exports = {
    add: function(a, b) {
        return a + b;
    },
    subtract: function(a, b) {
        return a - b;
    },
    multiply: (a, b) => a * b
};

// 方式三：类导出
class Calculator {
    add(a, b) {
        return a + b;
    }
    
    subtract(a, b) {
        return a - b;
    }
}

module.exports = Calculator;

// 方式一：整体导入
const math = require('./math');
console.log(math.add(5, 3)); // 8

// 方式二：解构导入
const { add, subtract } = require('./math');
console.log(add(5, 3)); // 8
console.log(subtract(5, 3)); // 2

// 方式三：别名导入
const { add: addNumbers, subtract: subtractNumbers } = require('./math');
console.log(addNumbers(5, 3)); // 8
console.log(subtractNumbers(5, 3)); // 2

// 导出
export const PI = 3.14159;
export function add(a, b) {
    return a + b;
}
export default class Calculator {
    constructor() {
        this.result = 0;
    }
    
    add(a) {
        this.result += a;
        return this;
    }
}

// 导入
import PI, { add } from './math.js';
import Calculator from './calculator.js';

console.log(PI); // 3.14159
console.log(add(5, 3)); // 8

const calc = new Calculator();
console.log(calc.add(5).result); // 5

// .eslintrc.js
module.exports = {
  env: {
    node: true,
    es2021: true,
    browser: false
  },
  extends: [
    'eslint:recommended',
    'plugin:node/recommended',
    'plugin:prettier/recommended'
  ],
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module'
  },
  plugins: ['node', 'prettier'],
  rules: {
    'no-console': 'warn',
    'no-unused-vars': 'error',
    'node/exports-style': ['error', 'module.exports'],
    'node/file-extension-in-import': ['error', 'always'],
    'node/prefer-global/process': 'error',
    'prettier/prettier': 'error'
  }
};

// .prettierrc
{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 80,
  "tabWidth": 2,
  "useTabs": false,
  "bracketSpacing": true,
  "arrowParens": "avoid"
}

// webpack.config.js
const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');

module.exports = {
  entry: './src/index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js',
    clean: true
  },
  mode: 'development',
  devtool: 'source-map',
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader',
          options: {
            presets: ['@babel/preset-env']
          }
        }
      },
      {
        test: /\.css$/,
        use: [MiniCssExtractPlugin.loader, 'css-loader']
      },
      {
        test: /\.(png|svg|jpg|jpeg|gif)$/,
        type: 'asset/resource'
      }
    ]
  },
  plugins: [
    new HtmlWebpackPlugin({
      template: './src/index.html'
    }),
    new MiniCssExtractPlugin({
      filename: 'styles.css'
    })
  ],
  devServer: {
    static: './dist',
    hot: true,
    port: 3000
  }
};

// src/app.js
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const userRoutes = require('./routes/userRoutes');
const errorHandler = require('./middleware/errorHandler');

const app = express();
const PORT = process.env.PORT || 3000;

// 中间件
app.use(helmet());
app.use(cors());
app.use(morgan('combined'));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 路由
app.use('/api/users', userRoutes);

// 健康检查
app.get('/health', (req, res) => {
  res.json({ status: 'OK', timestamp: new Date().toISOString() });
});

// 错误处理中间件
app.use(errorHandler);

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

module.exports = app;

// src/routes/userRoutes.js
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
const { validate } = require('../middleware/validation');

// 获取所有用户
router.get('/', userController.getAllUsers);

// 获取单个用户
router.get('/:id', userController.getUserById);

// 创建用户
router.post('/', validate('createUser'), userController.createUser);

// 更新用户
router.put('/:id', validate('updateUser'), userController.updateUser);

// 删除用户
router.delete('/:id', userController.deleteUser);

module.exports = router;

// src/controllers/userController.js
const User = require('../models/userModel');

// 获取所有用户
exports.getAllUsers = async (req, res) => {
  try {
    const users = await User.find();
    res.json({
      success: true,
      count: users.length,
      data: users
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: 'Server error',
      error: error.message
    });
  }
};

// 获取单个用户
exports.getUserById = async (req, res) => {
  try {
    const user = await User.findById(req.params.id);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: 'User not found'
      });
    }
    res.json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: 'Server error',
      error: error.message
    });
  }
};

// 创建用户
exports.createUser = async (req, res) => {
  try {
    const user = await User.create(req.body);
    res.status(201).json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      message: 'Validation error',
      error: error.message
    });
  }
};

// 更新用户
exports.updateUser = async (req, res) => {
  try {
    const user = await User.findByIdAndUpdate(
      req.params.id,
      req.body,
      { new: true, runValidators: true }
    );
    if (!user) {
      return res.status(404).json({
        success: false,
        message: 'User not found'
      });
    }
    res.json({
      success: true,
      data: user
    });
  } catch (error) {
    res.status(400).json({
      success: false,
      message: 'Validation error',
      error: error.message
    });
  }
};

// 删除用户
exports.deleteUser = async (req, res) => {
  try {
    const user = await User.findByIdAndDelete(req.params.id);
    if (!user) {
      return res.status(404).json({
        success: false,
        message: 'User not found'
      });
    }
    res.json({
      success: true,
      message: 'User deleted successfully'
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: 'Server error',
      error: error.message
    });
  }
};

// src/models/userModel.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, 'Name is required'],
    trim: true,
    maxlength: [50, 'Name cannot exceed 50 characters']
  },
  email: {
    type: String,
    required: [true, 'Email is required'],
    unique: true,
    lowercase: true,
    match: [
      /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/,
      'Please add a valid email'
    ]
  },
  password: {
    type: String,
    required: [true, 'Password is required'],
    minlength: [6, 'Password must be at least 6 characters'],
    select: false
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

// 预保存中间件
userSchema.pre('save', function(next) {
  this.updatedAt = Date.now();
  next();
});

// 创建索引
userSchema.index({ email: 1 });

module.exports = mongoose.model('User', userSchema);

// src/middleware/errorHandler.js
const errorHandler = (err, req, res, next) => {
  let error = { ...err };
  error.message = err.message;

  // 记录错误日志
  console.error(err);

  // Mongoose 错误处理
  if (err.name === 'CastError') {
    const message = 'Resource not found';
    error = { message, statusCode: 404 };
  }

  // Mongoose 重复字段错误
  if (err.code === 11000) {
    const message = 'Duplicate field value entered';
    error = { message, statusCode: 400 };
  }

  // Mongoose 验证错误
  if (err.name === 'ValidationError') {
    const message = Object.values(err.errors).map(val => val.message);
    error = { message, statusCode: 400 };
  }

  res.status(error.statusCode || 500).json({
    success: false,
    error: error.message || 'Server Error'
  });
};

module.exports = errorHandler;

// src/server.js
const WebSocket = require('ws');
const http = require('http');
const url = require('url');

const server = http.createServer();
const wss = new WebSocket.Server({ server });

const rooms = new Map(); // 存储房间信息
const users = new Map(); // 存储用户信息

// 处理连接
wss.on('connection', (ws, req) => {
  const parsedUrl = url.parse(req.url, true);
  const userId = parsedUrl.query.userId;
  const roomId = parsedUrl.query.roomId;

  // 用户加入房间
  if (userId && roomId) {
    users.set(userId, { ws, roomId });
    
    if (!rooms.has(roomId)) {
      rooms.set(roomId, new Set());
    }
    rooms.get(roomId).add(userId);

    // 广播用户加入消息
    broadcastToRoom(roomId, {
      type: 'user_joined',
      userId,
      timestamp: new Date().toISOString()
    });

    // 发送当前房间用户列表
    ws.send(JSON.stringify({
      type: 'room_users',
      users: Array.from(rooms.get(roomId))
    }));
  }

  // 处理消息
  ws.on('message', (message) => {
    try {
      const data = JSON.parse(message);
      
      switch (data.type) {
        case 'chat_message':
          handleChatMessage(userId, roomId, data);
          break;
        case 'typing':
          handleTyping(userId, roomId, data);
          break;
        case 'stop_typing':
          handleStopTyping(userId, roomId, data);
          break;
      }
    } catch (error) {
      console.error('Error parsing message:', error);
    }
  });

  // 处理断开连接
  ws.on('close', () => {
    if (userId) {
      const user = users.get(userId);
      if (user && user.roomId) {
        rooms.get(user.roomId).delete(userId);
        
        // 广播用户离开消息
        broadcastToRoom(user.roomId, {
          type: 'user_left',
          userId,
          timestamp: new Date().toISOString()
        });
      }
    }
  });
});

// 处理聊天消息
function handleChatMessage(userId, roomId, data) {
  const message = {
    type: 'chat_message',
    userId,
    username: data.username,
    content: data.content,
    timestamp: new Date().toISOString()
  };

  broadcastToRoom(roomId, message);
}

// 处理输入状态
function handleTyping(userId, roomId, data) {
  const typingMessage = {
    type: 'typing',
    userId,
    username: data.username,
    timestamp: new Date().toISOString()
  };

  broadcastToRoom(roomId, typingMessage, userId);
}

// 处理停止输入
function handleStopTyping(userId, roomId, data) {
  const stopTypingMessage = {
    type: 'stop_typing',
    userId,
    timestamp: new Date().toISOString()
  };

  broadcastToRoom(roomId, stopTypingMessage, userId);
}

// 广播消息到房间
function broadcastToRoom(roomId, message, excludeUserId) {
  const roomUsers = rooms.get(roomId);
  if (roomUsers) {
    roomUsers.forEach(userId => {
      if (userId !== excludeUserId) {
        const user = users.get(userId);
        if (user && user.ws.readyState === WebSocket.OPEN) {
          user.ws.send(JSON.stringify(message));
        }
      }
    });
  }
}

// 启动服务器
const PORT = process.env.PORT || 8080;
server.listen(PORT, () => {
  console.log(`WebSocket server running on port ${PORT}`);
});

// cli.js
#!/usr/bin/env node

const program = require('commander');
const inquirer = require('inquirer');
const chalk = require('chalk');
const figlet = require('figlet');

// 显示欢迎信息
console.log(
  chalk.cyan(
    figlet.textSync('Node CLI', {
      horizontalLayout: 'full',
      font: 'Big'
    })
  )
);

program
  .version('1.0.0')
  .description('A powerful Node.js CLI tool')
  .option('-v, --verbose', 'verbose output')
  .parse(process.argv);

program
  .command('init')
  .alias('i')
  .description('Initialize a new project')
  .action(() => {
    initProject();
  });

program
  .command('create <name>')
  .alias('c')
  .description('Create a new component')
  .option('-t, --type <type>', 'component type', 'component')
  .action((name, options) => {
    createComponent(name, options.type);
  });

program
  .command('build')
  .alias('b')
  .description('Build the project')
  .option('-p, --production', 'production build')
  .action((options) => {
    buildProject(options.production);
  });

// 初始化项目
async function initProject() {
  const answers = await inquirer.prompt([
    {
      type: 'input',
      name: 'name',
      message: 'Project name:',
      default: 'my-project'
    },
    {
      type: 'list',
      name: 'template',
      message: 'Select template:',
      choices: ['react', 'vue', 'angular', 'node']
    },
    {
      type: 'confirm',
      name: 'install',
      message: 'Install dependencies?',
      default: true
    }
  ]);

  console.log(chalk.green('✓ Project initialized successfully!'));
  
  if (answers.install) {
    console.log(chalk.yellow('Installing dependencies...'));
    // 这里添加安装依赖的逻辑
  }
}

// 创建组件
function createComponent(name, type) {
  const templates = {
    component: `
      import React from 'react';
      
      const ${name} = () => {
        return (
          <div className="${name.toLowerCase()}">
            <h2>${name}</h2>
            {/* Component content */}
          </div>
        );
      };
      
      export default ${name};
    `,
    page: `
      import React from 'react';
      
      const ${name} = () => {
        return (
          <div className="${name.toLowerCase()}">
            <h1>${name}</h1>
            {/* Page content */}
          </div>
        );
      };
      
      export default ${name};
    `,
    service: `
      class ${name}Service {
        // Service methods
      }
      
      export default new ${name}Service();
    `
  };

  const template = templates[type] || templates.component;
  
  console.log(chalk.green(`✓ ${type} '${name}' created successfully!`));
}

// 构建项目
function buildProject(production) {
  console.log(chalk.yellow('Building project...'));
  
  if (production) {
    console.log(chalk.cyan('🏗️  Production build...'));
    // 生产环境构建逻辑
  } else {
    console.log(chalk.cyan('🏗️  Development build...'));
    // 开发环境构建逻辑
  }
  
  console.log(chalk.green('✓ Build completed!'));
}

// 处理未找到的命令
if (!process.argv.slice(2).length) {
  program.help();
}

// 启用调试模式
node --inspect index.js

// 使用 Chrome DevTools
// 访问: chrome://inspect

// 使用 VS Code 调试
// F5 启动调试

// 启用 V8 Inspector
node --inspect-brk index.js

// Node.js 代码中启用调试
const inspector = require('inspector');
inspector.open(9229, '127.0.0.1');

// 性能分析
const v8 = require('v8');
const profiler = v8profiler;

profiler.startProfiling('profile', true);
// 执行代码
const profile = profiler.stopProfiling();
profile.export()
  .pipe(fs.createWriteStream('profile.cpuprofile'))
  .on('finish', () => {
    console.log('Profile saved');
  });

const winston = require('winston');
const path = require('path');

// 创建日志格式
const logFormat = winston.format.combine(
  winston.format.timestamp(),
  winston.format.errors({ stack: true }),
  winston.format.json()
);

// 创建日志记录器
const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: logFormat,
  defaultMeta: { service: 'user-service' },
  transports: [
    // 错误日志
    new winston.transports.File({ 
      filename: path.join(__dirname, 'logs', 'error.log'), 
      level: 'error' 
    }),
    // 所有日志
    new winston.transports.File({ 
      filename: path.join(__dirname, 'logs', 'combined.log') 
    })
  ]
});

// 开发环境下添加控制台输出
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

module.exports = logger;

// jest.config.js
module.exports = {
  testEnvironment: 'node',
  testMatch: ['**/__tests__/**/*.js', '**/?(*.)+(spec|test).js'],
  collectCoverage: true,
  coverageDirectory: 'coverage',
  coverageReporters: ['text', 'lcov', 'html'],
  collectCoverageFrom: [
    'src/**/*.js',
    '!src/**/*.test.js',
    '!src/**/*.spec.js'
  ],
  setupFiles: ['./tests/setup.js'],
  testTimeout: 10000
};

// tests/utils/database.js
const mongoose = require('mongoose');

// 连接测试数据库
const connectDB = async () => {
  try {
    await mongoose.connect(process.env.TEST_MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log('MongoDB connected');
  } catch (err) {
    console.error(err.message);
    process.exit(1);
  }
};

// 断开测试数据库
const disconnectDB = async () => {
  try {
    await mongoose.connection.close();
    console.log('MongoDB disconnected');
  } catch (err) {
    console.error(err.message);
  }
};

// 清除测试数据
const clearDB = async () => {
  const collections = mongoose.connection.collections;
  for (const key in collections) {
    await collections[key].deleteMany({});
  }
};

module.exports = { connectDB, disconnectDB, clearDB };

// tests/unit/user.test.js
const request = require('supertest');
const app = require('../../src/app');
const User = require('../../src/models/userModel');
const { connectDB, disconnectDB, clearDB } = require('../utils/database');

describe('User API', () => {
  beforeAll(async () => {
    await connectDB();
  });

  beforeEach(async () => {
    await clearDB();
  });

  afterAll(async () => {
    await disconnectDB();
  });

  describe('POST /api/users', () => {
    it('should create a new user', async () => {
      const res = await request(app)
        .post('/api/users')
        .send({
          name: 'John Doe',
          email: 'john@example.com',
          password: 'password123'
        });

      expect(res.statusCode).toEqual(201);
      expect(res.body.success).toBe(true);
      expect(res.body.data.name).toBe('John Doe');
    });

    it('should not create user with invalid email', async () => {
      const res = await request(app)
        .post('/api/users')
        .send({
          name: 'John Doe',
          email: 'invalid-email',
          password: 'password123'
        });

      expect(res.statusCode).toEqual(400);
      expect(res.body.success).toBe(false);
    });

    it('should not create user with duplicate email', async () => {
      await User.create({
        name: 'John Doe',
        email: 'john@example.com',
        password: 'password123'
      });

      const res = await request(app)
        .post('/api/users')
        .send({
          name: 'Jane Doe',
          email: 'john@example.com',
          password: 'password123'
        });

      expect(res.statusCode).toEqual(400);
      expect(res.body.success).toBe(false);
    });
    });

    describe('GET /api/users', () => {
      it('should get all users', async () => {
        await User.create([
          { name: 'User 1', email: 'user1@example.com', password: 'password123' },
          { name: 'User 2', email: 'user2@example.com', password: 'password123' }
        ]);

        const res = await request(app).get('/api/users');

        expect(res.statusCode).toEqual(200);
        expect(res.body.success).toBe(true);
        expect(res.body.count).toBe(2);
      });
    });
});

// tests/integration/auth.test.js
const request = require('supertest');
const app = require('../../src/app');
const User = require('../../src/models/userModel');
const jwt = require('jsonwebtoken');

describe('Authentication', () => {
  let token;

  beforeEach(async () => {
    await User.create({
      name: 'Test User',
      email: 'test@example.com',
      password: 'password123'
    });
  });

  describe('POST /api/auth/login', () => {
    it('should login user and return token', async () => {
      const res = await request(app)
        .post('/api/auth/login')
        .send({
          email: 'test@example.com',
          password: 'password123'
        });

      expect(res.statusCode).toEqual(200);
      expect(res.body.success).toBe(true);
      expect(res.body.token).toBeDefined();
      expect(res.body.data.user.email).toBe('test@example.com');

      token = res.body.token;
    });

    it('should not login with invalid credentials', async () => {
      const res = await request(app)
        .post('/api/auth/login')
        .send({
          email: 'test@example.com',
          password: 'wrongpassword'
        });

      expect(res.statusCode).toEqual(401);
      expect(res.body.success).toBe(false);
    });
  });

  describe('Protected routes', () => {
    it('should require authentication', async () => {
      const res = await request(app)
        .get('/api/users/profile');

      expect(res.statusCode).toEqual(401);
    });

    it('should allow access with valid token', async () => {
      const res = await request(app)
        .get('/api/users/profile')
        .set('Authorization', `Bearer ${token}`);

      expect(res.statusCode).toEqual(200);
      expect(res.body.success).toBe(true);
    });
  });
});

// 内存泄漏检测工具
const heapdump = require('heapdump');
const memwatch = require('memwatch-next');

// 监控内存使用
memwatch.on('leak', (info) => {
  console.log('Memory leak detected:', info);
  
  // 生成堆转储
  const filename = `/tmp/heapdump-${Date.now()}.heapsnapshot`;
  heapdump.writeSnapshot(filename, (err, filename) => {
    console.log('Heap dump written to', filename);
  });
});

// 内存使用监控
setInterval(() => {
  const used = process.memoryUsage();
  for (let key in used) {
    console.log(`${key} ${Math.round(used[key] / 1024 / 1024 * 100) / 100} MB`);
  }
}, 5000);

// 1. 使用流处理大文件
const fs = require('fs');
const zlib = require('zlib');

// 不好的做法：读取整个文件到内存
const data = fs.readFileSync('large-file.txt');
console.log(data.toString());

// 好的做法：使用流处理
fs.createReadStream('large-file.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('large-file.txt.gz'));

// 2. 避免缓存过大的数据
const cache = new Map();

function getData(key) {
  if (cache.size > 1000) {
    // 清除最旧的 50% 的缓存
    const keys = Array.from(cache.keys()).slice(0, cache.size / 2);
    keys.forEach(k => cache.delete(k));
  }
  
  return cache.get(key);
}

// 3. 使用对象池
const objectPool = [];

function getPooledObject() {
  return objectPool.length > 0 
    ? objectPool.pop() 
    : { data: null };
}

function releaseObject(obj) {
  obj.data = null;
  objectPool.push(obj);
}

// performance.js
const { performance } = require('perf_hooks');

class PerformanceMonitor {
  constructor() {
    this.metrics = {
      responseTime: [],
      memoryUsage: [],
      cpuUsage: []
    };
  }

  // 记录响应时间
  recordResponseTime(duration) {
    this.metrics.responseTime.push(duration);
    
    // 保持最近 1000 条记录
    if (this.metrics.responseTime.length > 1000) {
      this.metrics.responseTime.shift();
    }
  }

  // 记录内存使用
  recordMemoryUsage() {
    const usage = process.memoryUsage();
    this.metrics.memoryUsage.push({
      rss: usage.rss,
      heapTotal: usage.heapTotal,
      heapUsed: usage.heapUsed,
      external: usage.external
    });
  }

  // 计算平均响应时间
  getAverageResponseTime() {
    if (this.metrics.responseTime.length === 0) return 0;
    const sum = this.metrics.responseTime.reduce((a, b) => a + b, 0);
    return sum / this.metrics.responseTime.length;
  }

  // 获取内存使用统计
  getMemoryStats() {
    const recent = this.metrics.memoryUsage.slice(-10);
    const avgUsed = recent.reduce((sum, m) => sum + m.heapUsed, 0) / recent.length;
    
    return {
      current: this.metrics.memoryUsage[this.metrics.memoryUsage.length - 1],
      average: avgUsed
    };
  }

  // 启动监控
  start() {
    this.interval = setInterval(() => {
      this.recordMemoryUsage();
    }, 5000);
  }

  // 停止监控
  stop() {
    if (this.interval) {
      clearInterval(this.interval);
    }
  }
}

// 使用示例
const monitor = new PerformanceMonitor();
monitor.start();

// 中间件：记录响应时间
function responseTimeMiddleware(req, res, next) {
  const startTime = performance.now();
  
  res.on('finish', () => {
    const duration = performance.now() - startTime;
    monitor.recordResponseTime(duration);
  });
  
  next();
}

// 使用 async/await 替代回调
function oldWay(callback) {
  setTimeout(() => {
    callback(null, 'Result');
  }, 1000);
}

// 新的方式：async/await
async function newWay() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('Result');
    }, 1000);
  });
}

// 使用 Promise.all 并行处理
async function processParallel(tasks) {
  const promises = tasks.map(task => newWay(task));
  const results = await Promise.all(promises);
  return results;
}

// 使用 Promise.allSettled 处理部分失败
async function processWithErrors(tasks) {
  const results = await Promise.allSettled(tasks);
  const successes = results.filter(r => r.status === 'fulfilled');
  const failures = results.filter(r => r.status === 'rejected');
  
  return { successes, failures };
}

// 使用连接池
const { Pool } = require('pg');
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'myapp',
  password: 'password',
  port: 5432,
  max: 20,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000
});

// 批量操作
async function batchInsert(users) {
  const client = await pool.connect();
  try {
    await client.query('BEGIN');
    
    for (const user of users) {
      await client.query(
        'INSERT INTO users (name, email) VALUES ($1, $2)',
        [user.name, user.email]
      );
    }
    
    await client.query('COMMIT');
  } catch (error) {
    await client.query('ROLLBACK');
    throw error;
  } finally {
    client.release();
  }
}

// 缓存查询结果
const cache = new Map();

async function getCachedUser(userId) {
  if (cache.has(userId)) {
    return cache.get(userId);
  }
  
  const result = await pool.query('SELECT * FROM users WHERE id = $1', [userId]);
  const user = result.rows[0];
  
  // 缓存结果
  cache.set(userId, user);
  return user;
}

// src/utils/logger.js
const winston = require('winston');
const path = require('path');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({
      filename: path.join(__dirname, '../../logs/error.log'),
      level: 'error'
    }),
    new winston.transports.File({
      filename: path.join(__dirname, '../../logs/combined.log')
    })
  ]
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

module.exports = logger;

// src/middleware/errorHandler.js
class AppError extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.isOperational = true;
    this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
    
    Error.captureStackTrace(this, this.constructor);
  }
}

module.exports = AppError;

// src/middleware/errorHandler.js
const AppError = require('../utils/AppError');

const errorHandler = (err, req, res, next) => {
  err.statusCode = err.statusCode || 500;
  err.status = err.status || 'error';
  
  // 开发环境返回详细错误
  if (process.env.NODE_ENV === 'development') {
    res.status(err.statusCode).json({
      status: err.status,
      error: err,
      message: err.message,
      stack: err.stack
    });
  }
  
  // 生产环境返回简洁错误
  if (process.env.NODE_ENV === 'production') {
    // 信任的操作错误
    if (err.isOperational) {
      res.status(err.statusCode).json({
        status: err.status,
        message: err.message
      });
    }
    
    // 编程错误或未知错误
    res.status(500).json({
      status: 'error',
      message: 'Something went wrong!'
    });
  }
};

module.exports = errorHandler;

// src/app.js
const errorHandler = require('./middleware/errorHandler');

// 处理未处理的 Promise 拒绝
process.on('unhandledRejection', (err) => {
  console.log('UNHANDLED REJECTION! 💥');
  throw err;
});

// 处理未捕获的异常
process.on('uncaughtException', (err) => {
  console.log('UNCAUGHT EXCEPTION! 💥');
  console.error(err.name, err.message);
  process.exit(1);
});

// 全局错误处理中间件
app.use(errorHandler);

// src/middleware/security.js
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');
const mongoSanitize = require('express-mongo-sanitize');
const xss = require('xss-clean');
const hpp = require('hpp');

// 安全头设置
app.use(helmet());

// 限流
const limiter = rateLimit({
  max: 100,
  windowMs: 60 * 60 * 1000, // 1 小时
  message: 'Too many requests from this IP, please try again after an hour'
});
app.use('/api', limiter);

// 数据库查询注入
app.use(mongoSanitize());

// XSS 防护
app.use(xss());

// HTTP 参数污染
app.use(hpp({
  whitelist: ['duration', 'ratingsQuantity', 'ratingsAverage', 'price', 'difficulty']
}));

// src/config/config.js
require('dotenv').config({ path: './.env' });

const config = {
  nodeEnv: process.env.NODE_ENV || 'development',
  port: process.env.PORT || 3000,
  dbUrl: process.env.DATABASE_URL,
  jwtSecret: process.env.JWT_SECRET,
  jwtExpiresIn: process.env.JWT_EXPIRES_IN || '90d',
  cookieExpires: process.env.COOKIE_EXPIRES_IN || '90d',
  cookieSecure: process.env.NODE_ENV === 'production'
};

module.exports = config;

// .eslintrc.js
module.exports = {
  env: {
    node: true,
    es2021: true,
    jest: true
  },
  extends: [
    'eslint:recommended',
    'plugin:node/recommended'
  ],
  parserOptions: {
    ecmaVersion: 2021,
    sourceType: 'module'
  },
  rules: {
    'node/no-unsupported-features/es-syntax': ['error', { ignores: ['modules'] }],
    'node/no-unpublished-import': ['error', { allowModules: [] }],
    'node/no-missing-import': ['error', { allowModules: [] }],
    'node/no-extraneous-import': ['error', { allowModules: [] }],
    'node/no-extraneous-require': ['error'],
    'node/no-deprecated-api': ['error'],
    'node/no-unpublished-require': ['error', { allowModules: [] }],
    'node/no-missing-require': ['error', { allowModules: [] }],
    'node/file-extension-in-import': ['error', 'always'],
    'node/exports-style': ['error', 'module.exports'],
    'node/prefer-global/process': ['error'],
    'node/prefer-global/buffer': ['error'],
    'node/prefer-global/console': ['error'],
    'node/prefer-global/url': ['error'],
    'node/prefer-global/url-search-params': ['error'],
    'node/prefer-global/text-decoder': ['error'],
    'node/prefer-global/text-encoder': ['error']
  }
};

// .prettierrc
{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 80,
  "tabWidth": 2,
  "useTabs": false,
  "bracketSpacing": true,
  "arrowParens": "avoid",
  "endOfLine": "lf",
  "bracketSameLine": false
}

// 动态端口配置
const port = process.env.PORT || 3000;

server.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

// 或使用找端口工具
const findPort = require('find-free-port');

findPort(3000, 3100, (err, freePort) => {
  if (err) {
    console.error(err);
    return;
  }
  server.listen(freePort, () => {
    console.log(`Server running on port ${freePort}`);
  });
});

// 监控内存使用
const memoryUsage = process.memoryUsage();
console.log(memoryUsage);

// 手动触发垃圾回收
if (global.gc) {
  global.gc();
}

// 使用 heapdump 分析内存泄漏
const heapdump = require('heapdump');

// 在需要的时候生成堆转储
heapdump.writeSnapshot((err, filename) => {
  console.log('Heap dump written to', filename);
});

// 阻塞操作示例
function blockingOperation() {
  const start = Date.now();
  while (Date.now() - start < 1000) {
    // 阻塞事件循环
  }
}

// 非阻塞操作
async function nonBlockingOperation() {
  await new Promise(resolve => setTimeout(resolve, 1000));
}

// 使用 setImmediate 优化
function scheduleOperation() {
  setImmediate(() => {
    // 操作
  });
}

// 配置连接池
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'myapp',
  password: 'password',
  port: 5432,
  max: 20,          // 最大连接数
  min: 2,           // 最小连接数
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000
});

// 监控连接池状态
pool.on('connect', (client) => {
  console.log('Client connected');
});

pool.on('remove', (client) => {
  console.log('Client disconnected');
});

// 健康检查
async function checkPoolHealth() {
  const clients = await pool.query('SELECT count(*) as total FROM pg_stat_activity');
  console.log('Active connections:', clients.rows[0].total);
}