🖥️ 后端技术 - NODEJS

What is Node.js? What are its main features and advantages?

考察点：Node.js基础概念。

答案：

Node.js是一个基于Chrome V8引擎的JavaScript运行时环境，它允许JavaScript代码在服务器端运行。Node.js采用事件驱动、非阻塞I/O模型，使其在构建可扩展的网络应用程序时非常高效。

主要特点：

1. 单线程事件循环：采用单线程处理多个并发连接
2. 非阻塞I/O：异步处理I/O操作，避免阻塞
3. 跨平台支持：支持Windows、Linux、macOS等多个平台
4. 丰富的生态系统：拥有庞大的npm包管理系统

主要优势：

• 高性能：基于V8引擎，执行效率高
• 实时应用：适合构建聊天应用、在线游戏等实时应用
• 统一语言栈：前后端都使用JavaScript，降低学习成本
• 活跃社区：丰富的第三方库和工具支持

适用场景：

• RESTful API开发
• 实时Web应用（WebSocket）
• 微服务架构
• I/O密集型应用

How does the event loop mechanism work in Node.js?

考察点：事件循环理解。

答案：

Node.js的事件循环是其核心机制，负责处理异步操作和回调函数。它采用单线程模型，通过事件循环来管理和调度各种异步任务。

事件循环的六个阶段：

1. Timer阶段：执行setTimeout()和setInterval()的回调
2. Pending callbacks阶段：执行延迟到下一个循环迭代的I/O回调
3. Idle, prepare阶段：仅供内部使用
4. Poll阶段：获取新的I/O事件，执行与I/O相关的回调
5. Check阶段：执行setImmediate()回调
6. Close callbacks阶段：执行一些关闭的回调函数

执行优先级：

// 微任务队列优先级最高
process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('Promise'));

// 宏任务按阶段执行
setTimeout(() => console.log('setTimeout'), 0);
setImmediate(() => console.log('setImmediate'));

// 输出顺序：nextTick -> Promise -> setTimeout -> setImmediate

关键概念：

• 微任务：process.nextTick、Promise.then等，在每个阶段结束后立即执行
• 宏任务：setTimeout、setInterval、setImmediate等，按阶段顺序执行
• 阻塞操作：同步操作会阻塞事件循环，应避免使用

What is npm? How to use npm to manage project dependencies?

考察点：包管理基础。

答案：

npm（Node Package Manager）是Node.js的包管理工具，用于管理和分享JavaScript代码包。它是世界上最大的软件包注册表，包含数百万个可重用的代码包。

核心功能：

• 安装和管理第三方包
• 管理项目依赖关系
• 发布和分享代码包
• 运行项目脚本

常用命令：

# 初始化项目
npm init
npm init -y  # 使用默认配置

# 安装依赖
npm install express          # 安装到dependencies
npm install --save-dev jest  # 安装到devDependencies
npm install -g nodemon       # 全局安装

# 管理依赖
npm uninstall express        # 卸载包
npm update                   # 更新所有包
npm outdated                 # 查看过时的包

# 运行脚本
npm run start
npm run test
npm run build

package.json配置：

{
  "name": "my-app",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.18.0"
  },
  "devDependencies": {
    "jest": "^28.0.0"
  },
  "scripts": {
    "start": "node index.js",
    "test": "jest"
  }
}

依赖版本管理：

• ^1.2.3：兼容版本（1.x.x）
• ~1.2.3：补丁版本（1.2.x）
• 1.2.3：精确版本

What is the module system in Node.js? What are the differences between CommonJS and ES Module?

考察点：模块系统理解。

答案：

Node.js支持两种主要的模块系统：CommonJS（默认）和ES Module（ES6模块）。模块系统用于组织代码，实现代码的复用和封装。

CommonJS模块系统：

// 导出模块 (math.js)
function add(a, b) {
  return a + b;
}
module.exports = { add };
// 或者
exports.add = add;

// 导入模块 (app.js)
const { add } = require('./math');
const math = require('./math');
console.log(add(1, 2)); // 3

ES Module模块系统：

// 导出模块 (math.mjs 或设置 "type": "module")
export function add(a, b) {
  return a + b;
}
export default { add };

// 导入模块
import { add } from './math.mjs';
import math from './math.mjs';
console.log(add(1, 2)); // 3

主要区别对比：

启用ES Module方式：

1. 文件扩展名使用.mjs
2. package.json中设置"type": "module"
3. 使用--input-type=module标志

最佳实践：

• 新项目建议使用ES Module
• 现有CommonJS项目可逐步迁移
• 注意两种模块系统的互操作性

How to handle file operations in Node.js?

考察点：文件系统操作。

答案：

Node.js提供了强大的文件系统模块（fs）来处理文件操作，支持同步和异步两种方式。推荐使用异步方法以避免阻塞事件循环。

基本文件操作：

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

// 异步读取文件
fs.readFile('data.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Promise方式（Node.js 10+）
const fsPromises = require('fs').promises;
async function readFileAsync() {
  try {
    const data = await fsPromises.readFile('data.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

// 写入文件
fs.writeFile('output.txt', 'Hello World', 'utf8', (err) => {
  if (err) throw err;
  console.log('文件已保存');
});

常用文件操作方法：

// 检查文件是否存在
fs.access('file.txt', fs.constants.F_OK, (err) => {
  console.log(err ? '文件不存在' : '文件存在');
});

// 获取文件信息
fs.stat('file.txt', (err, stats) => {
  if (err) throw err;
  console.log('文件大小:', stats.size);
  console.log('是否为文件:', stats.isFile());
  console.log('是否为目录:', stats.isDirectory());
});

// 创建目录
fs.mkdir('newDir', { recursive: true }, (err) => {
  if (err) throw err;
  console.log('目录已创建');
});

// 读取目录
fs.readdir('.', (err, files) => {
  if (err) throw err;
  console.log('目录内容:', files);
});

流式文件操作（大文件处理）：

const fs = require('fs');

// 创建可读流
const readStream = fs.createReadStream('large-file.txt');
readStream.on('data', chunk => {
  console.log('接收到数据块:', chunk.length);
});

// 文件复制
const readStream2 = fs.createReadStream('source.txt');
const writeStream = fs.createWriteStream('destination.txt');
readStream2.pipe(writeStream);

错误处理最佳实践：

• 始终检查错误参数
• 使用try-catch处理同步操作
• 使用Promise或async/await处理异步操作
• 验证文件路径和权限

How to create an HTTP server in Node.js?

考察点：HTTP服务基础。

答案：

Node.js内置的http模块提供了创建HTTP服务器的核心功能。可以创建基础的Web服务器来处理HTTP请求和响应。

基础HTTP服务器：

const http = require('http');
const url = require('url');

// 创建服务器
const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, true);
  const path = parsedUrl.pathname;
  const method = req.method;

  // 设置响应头
  res.writeHead(200, {
    'Content-Type': 'text/html; charset=utf-8',
    'Access-Control-Allow-Origin': '*'
  });

  // 路由处理
  if (path === '/' && method === 'GET') {
    res.end('<h1>欢迎访问首页</h1>');
  } else if (path === '/api/users' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ users: ['Alice', 'Bob'] }));
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('页面未找到');
  }
});

// 启动服务器
const PORT = 3000;
server.listen(PORT, () => {
  console.log(`服务器运行在 http://localhost:${PORT}`);
});

处理POST请求和数据：

const server = http.createServer((req, res) => {
  if (req.method === 'POST') {
    let body = '';
    
    // 接收数据
    req.on('data', chunk => {
      body += chunk.toString();
    });
    
    // 数据接收完成
    req.on('end', () => {
      try {
        const data = JSON.parse(body);
        console.log('接收到数据:', data);
        
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ message: '数据已接收', data }));
      } catch (error) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: '无效的JSON数据' }));
      }
    });
  }
});

使用Express框架简化开发：

const express = require('express');
const app = express();

// 中间件
app.use(express.json());
app.use(express.static('public'));

// 路由
app.get('/', (req, res) => {
  res.send('<h1>欢迎访问首页</h1>');
});

app.get('/api/users', (req, res) => {
  res.json({ users: ['Alice', 'Bob'] });
});

app.post('/api/users', (req, res) => {
  const { name } = req.body;
  res.json({ message: `用户 ${name} 已创建` });
});

app.listen(3000, () => {
  console.log('Express服务器运行在端口3000');
});

HTTPS服务器：

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('private-key.pem'),
  cert: fs.readFileSync('certificate.pem')
};

const server = https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('HTTPS服务器运行中');
});

server.listen(443);

What is middleware? How to use it in Express?

考察点：中间件概念。

答案：

中间件是Express.js的核心概念，它是一个函数，在请求-响应循环中具有访问请求对象（req）、响应对象（res）和下一个中间件函数（next）的能力。中间件可以执行代码、修改请求和响应对象、结束请求-响应循环或调用下一个中间件。

中间件函数结构：

function middleware(req, res, next) {
  // 执行中间件逻辑
  console.log('中间件被调用');
  
  // 调用next()传递控制权给下一个中间件
  next();
}

中间件类型和使用方式：

1. 应用级中间件：

const express = require('express');
const app = express();

// 全局中间件 - 所有请求都会执行
app.use((req, res, next) => {
  console.log('请求时间:', new Date().toISOString());
  console.log('请求方法:', req.method);
  console.log('请求路径:', req.path);
  next();
});

// 路径特定中间件
app.use('/api', (req, res, next) => {
  console.log('API请求');
  next();
});

2. 路由级中间件：

const router = express.Router();

// 路由中间件
router.use((req, res, next) => {
  console.log('路由中间件');
  next();
});

router.get('/users', (req, res) => {
  res.json({ users: [] });
});

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

3. 内置中间件：

// 解析JSON请求体
app.use(express.json());

// 解析URL编码数据
app.use(express.urlencoded({ extended: true }));

// 提供静态文件服务
app.use(express.static('public'));

4. 第三方中间件：

const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

// 跨域中间件
app.use(cors());

// 安全头中间件
app.use(helmet());

// 日志中间件
app.use(morgan('combined'));

5. 自定义中间件：

// 身份验证中间件
function authenticate(req, res, next) {
  const token = req.headers.authorization;
  
  if (!token) {
    return res.status(401).json({ error: '未提供认证令牌' });
  }
  
  // 验证token逻辑
  try {
    const user = verifyToken(token);
    req.user = user;
    next();
  } catch (error) {
    res.status(401).json({ error: '无效令牌' });
  }
}

// 使用认证中间件
app.get('/protected', authenticate, (req, res) => {
  res.json({ message: `欢迎，${req.user.name}` });
});

错误处理中间件：

// 错误处理中间件 - 必须有4个参数
app.use((err, req, res, next) => {
  console.error('错误:', err.stack);
  
  if (err.status) {
    res.status(err.status).json({ error: err.message });
  } else {
    res.status(500).json({ error: '服务器内部错误' });
  }
});

中间件执行顺序：
中间件按照定义的顺序执行，必须调用next()来传递控制权，否则请求会挂起。

How to handle asynchronous operations in Node.js? What are the differences between callbacks, Promises, and async/await?

考察点：异步编程。

答案：

Node.js中的异步操作是其核心特性，主要有三种处理方式：回调函数（Callback）、Promise和async/await。每种方式都有其特点和适用场景。

1. 回调函数（Callback）：

const fs = require('fs');

// 传统回调方式
function readFileCallback(filename, callback) {
  fs.readFile(filename, 'utf8', (err, data) => {
    if (err) {
      callback(err, null);
    } else {
      callback(null, data);
    }
  });
}

// 使用回调
readFileCallback('data.txt', (err, data) => {
  if (err) {
    console.error('读取失败:', err);
  } else {
    console.log('文件内容:', data);
  }
});

// 回调地狱问题
fs.readFile('file1.txt', (err, data1) => {
  if (err) throw err;
  fs.readFile('file2.txt', (err, data2) => {
    if (err) throw err;
    fs.writeFile('result.txt', data1 + data2, (err) => {
      if (err) throw err;
      console.log('合并完成');
    });
  });
});

2. Promise：

const fs = require('fs').promises;

// Promise方式
function readFilePromise(filename) {
  return fs.readFile(filename, 'utf8');
}

// 使用Promise
readFilePromise('data.txt')
  .then(data => {
    console.log('文件内容:', data);
  })
  .catch(err => {
    console.error('读取失败:', err);
  });

// Promise链式调用解决回调地狱
fs.readFile('file1.txt', 'utf8')
  .then(data1 => {
    return fs.readFile('file2.txt', 'utf8')
      .then(data2 => ({ data1, data2 }));
  })
  .then(({ data1, data2 }) => {
    return fs.writeFile('result.txt', data1 + data2);
  })
  .then(() => {
    console.log('合并完成');
  })
  .catch(err => {
    console.error('操作失败:', err);
  });

3. async/await：

const fs = require('fs').promises;

// async/await方式
async function readFileAsync(filename) {
  try {
    const data = await fs.readFile(filename, 'utf8');
    console.log('文件内容:', data);
    return data;
  } catch (err) {
    console.error('读取失败:', err);
    throw err;
  }
}

// 使用async/await解决回调地狱
async function mergeFiles() {
  try {
    const data1 = await fs.readFile('file1.txt', 'utf8');
    const data2 = await fs.readFile('file2.txt', 'utf8');
    await fs.writeFile('result.txt', data1 + data2);
    console.log('合并完成');
  } catch (err) {
    console.error('操作失败:', err);
  }
}

// 并行执行多个异步操作
async function readMultipleFiles() {
  try {
    const [data1, data2, data3] = await Promise.all([
      fs.readFile('file1.txt', 'utf8'),
      fs.readFile('file2.txt', 'utf8'),
      fs.readFile('file3.txt', 'utf8')
    ]);
    
    console.log('所有文件读取完成');
    return { data1, data2, data3 };
  } catch (err) {
    console.error('读取失败:', err);
  }
}

三种方式对比：

最佳实践：

• 新项目推荐使用async/await
• 使用Promise.all()处理并行操作
• 适当使用工具函数封装常用异步操作
• 始终处理错误情况

How to handle errors in Node.js?

考察点：错误处理机制。

答案：

Node.js中的错误处理是保证应用程序稳定性和可靠性的关键。Node.js提供了多种错误处理机制来应对不同类型的错误情况。

错误类型：

1. 同步错误：在代码执行过程中立即发生的错误
2. 异步错误：在异步操作中发生的错误
3. 未捕获异常：程序中未被处理的错误

同步错误处理：

// 使用try-catch处理同步错误
try {
  const data = JSON.parse('无效的JSON');
  console.log(data);
} catch (error) {
  console.error('JSON解析错误:', error.message);
}

// 函数中的错误处理
function divide(a, b) {
  if (b === 0) {
    throw new Error('除数不能为零');
  }
  return a / b;
}

try {
  const result = divide(10, 0);
  console.log(result);
} catch (error) {
  console.error('计算错误:', error.message);
}

异步错误处理：

1. 回调函数错误处理：

const fs = require('fs');

// Node.js错误优先回调模式
fs.readFile('nonexistent.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('文件读取错误:', err.message);
    return;
  }
  console.log('文件内容:', data);
});

// 自定义错误优先回调
function asyncOperation(callback) {
  setTimeout(() => {
    const random = Math.random();
    if (random > 0.5) {
      callback(null, '操作成功');
    } else {
      callback(new Error('操作失败'));
    }
  }, 1000);
}

asyncOperation((err, result) => {
  if (err) {
    console.error('异步操作错误:', err.message);
  } else {
    console.log('结果:', result);
  }
});

2. Promise错误处理：

const fs = require('fs').promises;

// Promise错误处理
fs.readFile('nonexistent.txt', 'utf8')
  .then(data => {
    console.log('文件内容:', data);
  })
  .catch(err => {
    console.error('Promise错误:', err.message);
  });

// Promise链中的错误传播
Promise.resolve()
  .then(() => {
    throw new Error('Promise链中的错误');
  })
  .then(() => {
    console.log('这里不会执行');
  })
  .catch(err => {
    console.error('捕获到错误:', err.message);
  });

3. async/await错误处理：

async function handleAsyncErrors() {
  try {
    const data = await fs.readFile('nonexistent.txt', 'utf8');
    console.log('文件内容:', data);
  } catch (err) {
    console.error('async/await错误:', err.message);
  }
}

// 多个异步操作的错误处理
async function multipleAsyncOperations() {
  try {
    const results = await Promise.allSettled([
      fs.readFile('file1.txt', 'utf8'),
      fs.readFile('file2.txt', 'utf8'),
      fs.readFile('nonexistent.txt', 'utf8')
    ]);
    
    results.forEach((result, index) => {
      if (result.status === 'fulfilled') {
        console.log(`文件${index + 1}读取成功:`, result.value.substring(0, 50));
      } else {
        console.error(`文件${index + 1}读取失败:`, result.reason.message);
      }
    });
  } catch (err) {
    console.error('批量操作错误:', err.message);
  }
}

全局错误处理：

// 捕获未处理的Promise拒绝
process.on('unhandledRejection', (reason, promise) => {
  console.error('未处理的Promise拒绝:', reason);
  // 记录日志、清理资源等
  process.exit(1);
});

// 捕获未捕获的异常
process.on('uncaughtException', (err) => {
  console.error('未捕获的异常:', err);
  // 记录日志、清理资源等
  process.exit(1);
});

// Express错误处理中间件
app.use((err, req, res, next) => {
  console.error('Express错误:', err.stack);
  
  if (err.status) {
    res.status(err.status).json({
      error: err.message,
      stack: process.env.NODE_ENV === 'development' ? err.stack : undefined
    });
  } else {
    res.status(500).json({ error: '内部服务器错误' });
  }
});

自定义错误类：

class CustomError extends Error {
  constructor(message, statusCode = 500) {
    super(message);
    this.name = this.constructor.name;
    this.statusCode = statusCode;
    Error.captureStackTrace(this, this.constructor);
  }
}

class ValidationError extends CustomError {
  constructor(message) {
    super(message, 400);
  }
}

// 使用自定义错误
function validateUser(user) {
  if (!user.email) {
    throw new ValidationError('邮箱是必填项');
  }
  if (!user.password) {
    throw new ValidationError('密码是必填项');
  }
}

最佳实践：

• 始终处理错误，不要让错误静默失败
• 使用具体的错误信息和错误码
• 在生产环境中隐藏敏感的错误详情
• 建立完善的日志系统
• 使用错误监控工具（如Sentry）

What is Buffer in Node.js? How to use it?

考察点：Buffer数据处理。

答案：

Buffer是Node.js中用于处理二进制数据的全局对象。在Node.js中，Buffer类是用来创建一个专门存放二进制数据的缓存区，类似于整数数组，但对应于V8堆内存之外的一块原始内存。

Buffer的特点：

• 用于处理二进制数据流
• 固定大小，创建后无法改变
• 直接操作内存，性能高效
• 全局可用，无需require

创建Buffer的方式：

// 1. 创建指定长度的Buffer（已废弃，不安全）
// const buf1 = new Buffer(10); // 不推荐

// 2. 安全的创建方式
const buf1 = Buffer.alloc(10);          // 创建10字节的Buffer，填充0
const buf2 = Buffer.allocUnsafe(10);    // 创建10字节的Buffer，不初始化（更快但不安全）
const buf3 = Buffer.from('hello');      // 从字符串创建
const buf4 = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]); // 从数组创建

console.log(buf1); // <Buffer 00 00 00 00 00 00 00 00 00 00>
console.log(buf3); // <Buffer 68 65 6c 6c 6f>

Buffer与字符串转换：

// 字符串转Buffer
const str = 'Hello Node.js';
const buf = Buffer.from(str, 'utf8');
console.log(buf); // <Buffer 48 65 6c 6c 6f 20 4e 6f 64 65 2e 6a 73>

// Buffer转字符串
const bufToStr = buf.toString('utf8');
console.log(bufToStr); // Hello Node.js

// 支持多种编码
const buf2 = Buffer.from('你好', 'utf8');
console.log(buf2.toString('utf8'));    // 你好
console.log(buf2.toString('base64'));  // 5L2g5aW9
console.log(buf2.toString('hex'));     // e4bda0e5a5bd

Buffer操作方法：

const buf = Buffer.from('Hello World');

// 基本属性和方法
console.log(buf.length);        // 11 - Buffer长度
console.log(buf[0]);           // 72 - 第一个字节（H的ASCII码）

// 读取和写入
buf.write('Hi', 0, 'utf8');    // 在位置0写入'Hi'
console.log(buf.toString());    // Hi World

// 切片（不复制数据，共享内存）
const slice = buf.slice(0, 2);
console.log(slice.toString());  // Hi

// 复制Buffer
const buf2 = Buffer.alloc(5);
buf.copy(buf2, 0, 0, 5);       // 复制buf的前5个字节到buf2
console.log(buf2.toString());   // Hi Wo

// 填充Buffer
const buf3 = Buffer.alloc(10);
buf3.fill('ab');
console.log(buf3.toString());   // ababababab

Buffer的实际应用场景：

1. 文件操作：

const fs = require('fs');

// 读取二进制文件
fs.readFile('image.jpg', (err, data) => {
  if (err) throw err;
  console.log('文件大小:', data.length, '字节');
  console.log('文件类型:', data.slice(0, 4)); // 读取文件头
});

// 写入二进制数据
const imageBuffer = Buffer.from([/* 图片二进制数据 */]);
fs.writeFile('output.jpg', imageBuffer, (err) => {
  if (err) throw err;
  console.log('图片已保存');
});

2. 网络通信：

const net = require('net');

const server = net.createServer((socket) => {
  socket.on('data', (data) => {
    // data是Buffer对象
    console.log('接收到数据:', data.length, '字节');
    console.log('数据内容:', data.toString());
    
    // 发送Buffer响应
    const response = Buffer.from('数据已收到', 'utf8');
    socket.write(response);
  });
});

server.listen(8080);

3. 加密和哈希：

const crypto = require('crypto');

const data = 'sensitive data';
const buffer = Buffer.from(data, 'utf8');

// 创建哈希
const hash = crypto.createHash('sha256');
hash.update(buffer);
const hashResult = hash.digest('hex');
console.log('SHA256哈希:', hashResult);

// Base64编码
const base64 = buffer.toString('base64');
console.log('Base64编码:', base64);

Buffer性能优化：

// 预分配Buffer避免频繁创建
const pool = Buffer.allocUnsafe(1024 * 1024); // 1MB缓冲池
let offset = 0;

function getBuffer(size) {
  if (offset + size > pool.length) {
    offset = 0; // 重置偏移
  }
  const buf = pool.slice(offset, offset + size);
  offset += size;
  return buf;
}

// 使用Buffer.concat合并多个Buffer
const buffers = [
  Buffer.from('Hello '),
  Buffer.from('Node.js '),
  Buffer.from('World')
];
const combined = Buffer.concat(buffers);
console.log(combined.toString()); // Hello Node.js World

注意事项：

• Buffer大小固定，无法动态调整
• 使用Buffer.alloc()而非new Buffer()
• 注意内存泄漏，及时释放大的Buffer
• 处理用户输入时注意Buffer长度限制

What is cluster mode in Node.js? How to implement load balancing?

考察点：集群架构理解。

答案：

Node.js集群模式是一种通过创建多个工作进程来充分利用多核CPU系统的方法。由于Node.js是单线程的，集群模式可以帮助应用程序处理更多的并发连接，提高应用性能和可靠性。

集群模式的工作原理：

• 主进程（Master）负责管理工作进程（Worker）
• 工作进程处理实际的HTTP请求
• 主进程通过负载均衡算法分发请求到工作进程

基本集群实现：

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`主进程 ${process.pid} 正在运行`);
  
  // 创建工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  // 监听工作进程退出
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 已退出`);
    console.log('重新启动工作进程...');
    cluster.fork();
  });
  
  // 监听工作进程上线
  cluster.on('online', (worker) => {
    console.log(`工作进程 ${worker.process.pid} 已上线`);
  });
  
} else {
  // 工作进程代码
  const server = http.createServer((req, res) => {
    res.writeHead(200);
    res.end(`Hello from process ${process.pid}\n`);
  });
  
  server.listen(3000, () => {
    console.log(`工作进程 ${process.pid} 监听端口 3000`);
  });
}

高级集群管理：

const cluster = require('cluster');
const http = require('http');
const os = require('os');

class ClusterManager {
  constructor(options = {}) {
    this.workers = new Map();
    this.maxWorkers = options.maxWorkers || os.cpus().length;
    this.restartDelay = options.restartDelay || 1000;
    this.maxRestarts = options.maxRestarts || 5;
  }
  
  start() {
    if (cluster.isMaster) {
      this.startMaster();
    } else {
      this.startWorker();
    }
  }
  
  startMaster() {
    console.log(`主进程 ${process.pid} 启动，创建 ${this.maxWorkers} 个工作进程`);
    
    // 创建工作进程
    for (let i = 0; i < this.maxWorkers; i++) {
      this.createWorker();
    }
    
    // 优雅关闭
    process.on('SIGTERM', () => {
      console.log('接收到SIGTERM信号，开始优雅关闭...');
      this.shutdown();
    });
    
    process.on('SIGINT', () => {
      console.log('接收到SIGINT信号，开始优雅关闭...');
      this.shutdown();
    });
  }
  
  createWorker() {
    const worker = cluster.fork();
    const workerData = {
      worker,
      restarts: 0,
      startTime: Date.now()
    };
    
    this.workers.set(worker.id, workerData);
    
    worker.on('exit', (code, signal) => {
      const data = this.workers.get(worker.id);
      if (data && data.restarts < this.maxRestarts) {
        console.log(`工作进程 ${worker.process.pid} 异常退出，准备重启...`);
        setTimeout(() => {
          this.createWorker();
        }, this.restartDelay);
        data.restarts++;
      } else {
        console.log(`工作进程 ${worker.process.pid} 重启次数过多，不再重启`);
      }
      this.workers.delete(worker.id);
    });
    
    return worker;
  }
  
  startWorker() {
    const server = http.createServer((req, res) => {
      // 模拟一些处理逻辑
      const start = Date.now();
      
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({
        pid: process.pid,
        timestamp: new Date().toISOString(),
        uptime: process.uptime(),
        memoryUsage: process.memoryUsage()
      }));
    });
    
    server.listen(3000, () => {
      console.log(`工作进程 ${process.pid} 监听端口 3000`);
    });
    
    // 优雅关闭工作进程
    process.on('SIGTERM', () => {
      console.log(`工作进程 ${process.pid} 接收到关闭信号`);
      server.close(() => {
        process.exit(0);
      });
    });
  }
  
  shutdown() {
    for (const [id, data] of this.workers) {
      data.worker.kill('SIGTERM');
    }
    
    setTimeout(() => {
      process.exit(0);
    }, 5000);
  }
}

// 启动集群
const clusterManager = new ClusterManager({
  maxWorkers: 4,
  restartDelay: 2000,
  maxRestarts: 3
});

clusterManager.start();

使用PM2进行集群管理：

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'my-app',
    script: 'app.js',
    instances: 'max',  // 或指定数量，如 4
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production',
      PORT: 3000
    },
    error_file: './logs/err.log',
    out_file: './logs/out.log',
    log_file: './logs/combined.log',
    time: true
  }]
};

// 启动命令
// pm2 start ecosystem.config.js
// pm2 reload my-app  // 零停机重启
// pm2 scale my-app 8 // 扩展到8个实例

负载均衡策略：

// 自定义负载均衡
const cluster = require('cluster');

if (cluster.isMaster) {
  const workers = [];
  let current = 0;
  
  // 轮询负载均衡
  cluster.setupMaster({
    schedulingPolicy: cluster.SCHED_NONE // 禁用默认负载均衡
  });
  
  for (let i = 0; i < 4; i++) {
    workers.push(cluster.fork());
  }
  
  // 自定义请求分发逻辑
  const server = require('net').createServer({ pauseOnConnect: true }, (connection) => {
    const worker = workers[current];
    current = (current + 1) % workers.length;
    worker.send('sticky-session:connection', connection);
  });
  
  server.listen(3000);
}

集群监控和健康检查：

// 健康检查和监控
class HealthMonitor {
  constructor() {
    this.stats = new Map();
  }
  
  startMonitoring() {
    setInterval(() => {
      for (const [id, worker] of Object.entries(cluster.workers)) {
        worker.send('health-check');
      }
    }, 30000);
    
    cluster.on('message', (worker, message) => {
      if (message.type === 'health-response') {
        this.updateStats(worker.id, message.data);
      }
    });
  }
  
  updateStats(workerId, data) {
    this.stats.set(workerId, {
      ...data,
      lastUpdated: Date.now()
    });
  }
  
  getClusterStats() {
    return Array.from(this.stats.entries()).map(([id, stats]) => ({
      workerId: id,
      ...stats
    }));
  }
}

最佳实践：

• 根据CPU核心数量设置工作进程数量
• 实现优雅的进程重启和关闭
• 监控工作进程的健康状态
• 使用进程管理工具（如PM2）
• 实现请求日志和错误跟踪
• 考虑使用反向代理（如Nginx）进行负载均衡

How to connect and operate databases in Node.js?

考察点：数据库集成。

答案：

Node.js支持多种数据库连接方式，包括关系型数据库（MySQL、PostgreSQL）和NoSQL数据库（MongoDB、Redis）。可以使用原生驱动或ORM/ODM工具进行数据库操作。

MongoDB连接和操作：

// 使用mongoose ODM
const mongoose = require('mongoose');

// 连接MongoDB
async function connectDB() {
  try {
    await mongoose.connect('mongodb://localhost:27017/myapp', {
      useNewUrlParser: true,
      useUnifiedTopology: true
    });
    console.log('MongoDB连接成功');
  } catch (error) {
    console.error('MongoDB连接失败:', error);
    process.exit(1);
  }
}

// 定义Schema和Model
const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, min: 0 },
  createdAt: { type: Date, default: Date.now }
});

const User = mongoose.model('User', userSchema);

// CRUD操作
async function userOperations() {
  try {
    // 创建用户
    const newUser = new User({
      name: '张三',
      email: '[email protected]',
      age: 25
    });
    await newUser.save();
    
    // 查询用户
    const users = await User.find({ age: { $gte: 18 } });
    const user = await User.findOne({ email: '[email protected]' });
    
    // 更新用户
    await User.updateOne(
      { _id: user._id },
      { $set: { age: 26 } }
    );
    
    // 删除用户
    await User.deleteOne({ _id: user._id });
    
  } catch (error) {
    console.error('数据库操作错误:', error);
  }
}

MySQL连接和操作：

// 使用mysql2驱动
const mysql = require('mysql2/promise');

// 创建连接池
const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'myapp',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
});

// 数据库操作函数
class UserService {
  async createUser(userData) {
    const { name, email, age } = userData;
    const [result] = await pool.execute(
      'INSERT INTO users (name, email, age) VALUES (?, ?, ?)',
      [name, email, age]
    );
    return result.insertId;
  }
  
  async getUserById(id) {
    const [rows] = await pool.execute(
      'SELECT * FROM users WHERE id = ?',
      [id]
    );
    return rows[0];
  }
  
  async updateUser(id, userData) {
    const { name, email, age } = userData;
    const [result] = await pool.execute(
      'UPDATE users SET name = ?, email = ?, age = ? WHERE id = ?',
      [name, email, age, id]
    );
    return result.affectedRows;
  }
  
  async deleteUser(id) {
    const [result] = await pool.execute(
      'DELETE FROM users WHERE id = ?',
      [id]
    );
    return result.affectedRows;
  }
  
  async getUsers(limit = 10, offset = 0) {
    const [rows] = await pool.execute(
      'SELECT * FROM users LIMIT ? OFFSET ?',
      [limit, offset]
    );
    return rows;
  }
}

使用Sequelize ORM：

const { Sequelize, DataTypes } = require('sequelize');

// 创建Sequelize实例
const sequelize = new Sequelize('myapp', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql',
  logging: false, // 禁用SQL日志
  pool: {
    max: 10,
    min: 0,
    acquire: 30000,
    idle: 10000
  }
});

// 定义模型
const User = sequelize.define('User', {
  id: {
    type: DataTypes.INTEGER,
    primaryKey: true,
    autoIncrement: true
  },
  name: {
    type: DataTypes.STRING,
    allowNull: false
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: {
      isEmail: true
    }
  },
  age: {
    type: DataTypes.INTEGER,
    validate: {
      min: 0,
      max: 150
    }
  }
}, {
  timestamps: true,
  tableName: 'users'
});

// 同步数据库
async function syncDatabase() {
  try {
    await sequelize.authenticate();
    console.log('数据库连接成功');
    
    await sequelize.sync({ force: false });
    console.log('数据库同步完成');
  } catch (error) {
    console.error('数据库连接失败:', error);
  }
}

// 使用模型进行操作
async function userCRUD() {
  try {
    // 创建
    const user = await User.create({
      name: '李四',
      email: '[email protected]',
      age: 30
    });
    
    // 查询
    const users = await User.findAll({
      where: {
        age: {
          [Sequelize.Op.gte]: 18
        }
      },
      limit: 10,
      order: [['createdAt', 'DESC']]
    });
    
    // 更新
    await User.update(
      { age: 31 },
      { where: { id: user.id } }
    );
    
    // 删除
    await User.destroy({
      where: { id: user.id }
    });
    
  } catch (error) {
    console.error('操作失败:', error);
  }
}

Redis连接和操作：

const redis = require('redis');

// 创建Redis客户端
const client = redis.createClient({
  host: 'localhost',
  port: 6379,
  password: 'your-password',
  db: 0
});

client.on('connect', () => {
  console.log('Redis连接成功');
});

client.on('error', (err) => {
  console.error('Redis连接错误:', err);
});

// Redis操作
class CacheService {
  async set(key, value, expireTime = 3600) {
    try {
      const serializedValue = JSON.stringify(value);
      await client.setex(key, expireTime, serializedValue);
    } catch (error) {
      console.error('缓存设置失败:', error);
    }
  }
  
  async get(key) {
    try {
      const value = await client.get(key);
      return value ? JSON.parse(value) : null;
    } catch (error) {
      console.error('缓存获取失败:', error);
      return null;
    }
  }
  
  async delete(key) {
    try {
      await client.del(key);
    } catch (error) {
      console.error('缓存删除失败:', error);
    }
  }
  
  async exists(key) {
    try {
      return await client.exists(key);
    } catch (error) {
      console.error('缓存检查失败:', error);
      return false;
    }
  }
}

数据库连接管理最佳实践：

class DatabaseManager {
  constructor() {
    this.connections = new Map();
  }
  
  async connect(config) {
    try {
      let connection;
      
      switch (config.type) {
        case 'mongodb':
          connection = await mongoose.connect(config.url, config.options);
          break;
        case 'mysql':
          connection = mysql.createPool(config.options);
          break;
        case 'redis':
          connection = redis.createClient(config.options);
          break;
        default:
          throw new Error(`不支持的数据库类型: ${config.type}`);
      }
      
      this.connections.set(config.name, {
        type: config.type,
        connection,
        config
      });
      
      console.log(`${config.type} 数据库 ${config.name} 连接成功`);
      return connection;
    } catch (error) {
      console.error('数据库连接失败:', error);
      throw error;
    }
  }
  
  getConnection(name) {
    return this.connections.get(name)?.connection;
  }
  
  async closeAll() {
    for (const [name, { type, connection }] of this.connections) {
      try {
        if (type === 'mongodb') {
          await mongoose.disconnect();
        } else if (type === 'mysql') {
          await connection.end();
        } else if (type === 'redis') {
          connection.quit();
        }
        console.log(`${name} 连接已关闭`);
      } catch (error) {
        console.error(`关闭 ${name} 连接失败:`, error);
      }
    }
    this.connections.clear();
  }
}

// 使用示例
const dbManager = new DatabaseManager();

async function initDatabases() {
  await dbManager.connect({
    name: 'main',
    type: 'mysql',
    options: {
      host: 'localhost',
      user: 'root',
      password: 'password',
      database: 'myapp'
    }
  });
  
  await dbManager.connect({
    name: 'cache',
    type: 'redis',
    options: {
      host: 'localhost',
      port: 6379
    }
  });
}

What are streams in Node.js? What types are there?

考察点：流处理机制。

答案：

流（Stream）是Node.js中处理流式数据的抽象接口。Stream是一个抽象接口，用于读写数据的统一方式，特别适合处理大量数据，因为它允许你逐块处理数据，而不需要将整个数据集加载到内存中。

流的主要特点：

• 内存效率：逐块处理数据，避免内存溢出
• 时间效率：可以在数据到达时立即开始处理
• 管道化：可以通过pipe连接多个流形成处理链
• 事件驱动：基于EventEmitter，支持事件监听

四种主要流类型：

1. 可读流（Readable Stream）：

const fs = require('fs');
const { Readable } = require('stream');

// 文件可读流
const readStream = fs.createReadStream('large-file.txt', {
  encoding: 'utf8',
  highWaterMark: 1024 // 缓冲区大小
});

readStream.on('data', (chunk) => {
  console.log('接收到数据块:', chunk.length);
});

readStream.on('end', () => {
  console.log('数据读取完成');
});

readStream.on('error', (err) => {
  console.error('读取错误:', err);
});

// 自定义可读流
class NumberStream extends Readable {
  constructor(max) {
    super();
    this.current = 0;
    this.max = max;
  }
  
  _read() {
    if (this.current < this.max) {
      this.push(`数字: ${this.current++}\n`);
    } else {
      this.push(null); // 结束流
    }
  }
}

const numberStream = new NumberStream(5);
numberStream.on('data', chunk => console.log(chunk.toString()));

2. 可写流（Writable Stream）：

const fs = require('fs');
const { Writable } = require('stream');

// 文件可写流
const writeStream = fs.createWriteStream('output.txt');

writeStream.write('Hello ');
writeStream.write('World\n');
writeStream.end(); // 结束写入

writeStream.on('finish', () => {
  console.log('写入完成');
});

// 自定义可写流
class ConsoleWriter extends Writable {
  _write(chunk, encoding, callback) {
    console.log(`写入数据: ${chunk.toString()}`);
    callback();
  }
}

const consoleWriter = new ConsoleWriter();
consoleWriter.write('测试数据');
consoleWriter.end();

3. 双工流（Duplex Stream）：

const { Duplex } = require('stream');
const net = require('net');

// TCP套接字是双工流的例子
const server = net.createServer((socket) => {
  // socket既可读又可写
  socket.write('欢迎连接到服务器\n');
  
  socket.on('data', (data) => {
    console.log('接收到:', data.toString());
    socket.write(`回显: ${data}`);
  });
});

server.listen(3000);

// 自定义双工流
class EchoStream extends Duplex {
  _write(chunk, encoding, callback) {
    // 写入的数据会自动推送到可读端
    this.push(chunk);
    callback();
  }
  
  _read() {
    // 可读端的实现
  }
}

const echo = new EchoStream();
echo.on('data', chunk => console.log('回显:', chunk.toString()));
echo.write('Hello Duplex Stream');

4. 转换流（Transform Stream）：

const { Transform } = require('stream');
const fs = require('fs');

// 自定义转换流 - 转换为大写
class UpperCaseTransform extends Transform {
  _transform(chunk, encoding, callback) {
    const upperChunk = chunk.toString().toUpperCase();
    this.push(upperChunk);
    callback();
  }
}

// 使用转换流处理文件
const readStream = fs.createReadStream('input.txt');
const writeStream = fs.createWriteStream('output.txt');
const upperCaseTransform = new UpperCaseTransform();

readStream
  .pipe(upperCaseTransform)
  .pipe(writeStream);

// CSV解析转换流
class CSVParser extends Transform {
  constructor() {
    super({ objectMode: true });
    this.headers = null;
  }
  
  _transform(chunk, encoding, callback) {
    const lines = chunk.toString().split('\n');
    
    for (const line of lines) {
      if (!this.headers) {
        this.headers = line.split(',');
      } else if (line.trim()) {
        const values = line.split(',');
        const obj = {};
        this.headers.forEach((header, index) => {
          obj[header] = values[index];
        });
        this.push(obj);
      }
    }
    callback();
  }
}

流的管道操作：

const fs = require('fs');
const zlib = require('zlib');
const crypto = require('crypto');

// 复杂的流管道：读取 -> 压缩 -> 加密 -> 写入
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip()) // 压缩
  .pipe(crypto.createCipher('aes256', 'secret-key')) // 加密
  .pipe(fs.createWriteStream('output.txt.gz.enc')) // 写入
  .on('finish', () => {
    console.log('流管道处理完成');
  });

// 错误处理
const pipeline = require('stream').pipeline;

pipeline(
  fs.createReadStream('input.txt'),
  new UpperCaseTransform(),
  fs.createWriteStream('output.txt'),
  (err) => {
    if (err) {
      console.error('管道错误:', err);
    } else {
      console.log('管道成功完成');
    }
  }
);

流的高级应用：

// 背压处理（Backpressure）
const fs = require('fs');

function copyFile(src, dest) {
  return new Promise((resolve, reject) => {
    const readStream = fs.createReadStream(src);
    const writeStream = fs.createWriteStream(dest);
    
    readStream.on('data', (chunk) => {
      const canWriteMore = writeStream.write(chunk);
      
      // 如果写入缓冲区满了，暂停读取
      if (!canWriteMore) {
        readStream.pause();
        writeStream.once('drain', () => {
          readStream.resume();
        });
      }
    });
    
    readStream.on('end', () => {
      writeStream.end();
      resolve();
    });
    
    readStream.on('error', reject);
    writeStream.on('error', reject);
  });
}

// 对象模式流
class ObjectTransform extends Transform {
  constructor() {
    super({ objectMode: true });
  }
  
  _transform(obj, encoding, callback) {
    // 处理对象数据
    const processed = {
      ...obj,
      timestamp: new Date().toISOString(),
      processed: true
    };
    this.push(processed);
    callback();
  }
}

流的性能优化：

• 合理设置缓冲区大小（highWaterMark）
• 使用对象模式处理结构化数据
• 适当的背压处理
• 错误处理和资源清理
• 使用pipeline简化错误处理

适用场景：

• 大文件处理
• 网络数据传输
• 数据转换和处理
• 实时数据分析
• 媒体流处理

How to implement authentication and authorization in Node.js applications?

考察点：安全认证机制。

答案：

身份验证（Authentication）和授权（Authorization）是Node.js应用安全的核心组成部分。身份验证确认用户身份，授权决定用户可以访问哪些资源和执行哪些操作。

身份验证方法：

1. JWT（JSON Web Token）认证：

const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');
const express = require('express');

const app = express();
app.use(express.json());

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
const REFRESH_SECRET = process.env.REFRESH_SECRET || 'refresh-secret';

// 用户注册
app.post('/register', async (req, res) => {
  try {
    const { username, password, email } = req.body;
    
    // 密码哈希
    const saltRounds = 12;
    const hashedPassword = await bcrypt.hash(password, saltRounds);
    
    // 保存用户到数据库（示例）
    const user = {
      id: Date.now(),
      username,
      email,
      password: hashedPassword
    };
    
    res.status(201).json({ 
      message: '用户注册成功', 
      userId: user.id 
    });
  } catch (error) {
    res.status(500).json({ error: '注册失败' });
  }
});

// 用户登录
app.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    // 从数据库获取用户（示例）
    const user = await getUserByUsername(username);
    if (!user) {
      return res.status(401).json({ error: '用户名或密码错误' });
    }
    
    // 验证密码
    const isValidPassword = await bcrypt.compare(password, user.password);
    if (!isValidPassword) {
      return res.status(401).json({ error: '用户名或密码错误' });
    }
    
    // 生成访问令牌和刷新令牌
    const accessToken = jwt.sign(
      { 
        userId: user.id, 
        username: user.username,
        roles: user.roles || ['user']
      },
      JWT_SECRET,
      { expiresIn: '15m' }
    );
    
    const refreshToken = jwt.sign(
      { userId: user.id },
      REFRESH_SECRET,
      { expiresIn: '7d' }
    );
    
    // 保存刷新令牌到数据库
    await saveRefreshToken(user.id, refreshToken);
    
    res.json({
      accessToken,
      refreshToken,
      user: {
        id: user.id,
        username: user.username,
        email: user.email
      }
    });
  } catch (error) {
    res.status(500).json({ error: '登录失败' });
  }
});

// 令牌刷新
app.post('/refresh-token', async (req, res) => {
  try {
    const { refreshToken } = req.body;
    
    if (!refreshToken) {
      return res.status(401).json({ error: '刷新令牌缺失' });
    }
    
    // 验证刷新令牌
    const decoded = jwt.verify(refreshToken, REFRESH_SECRET);
    const storedToken = await getRefreshToken(decoded.userId);
    
    if (!storedToken || storedToken !== refreshToken) {
      return res.status(401).json({ error: '无效的刷新令牌' });
    }
    
    // 获取用户信息
    const user = await getUserById(decoded.userId);
    
    // 生成新的访问令牌
    const newAccessToken = jwt.sign(
      { 
        userId: user.id, 
        username: user.username,
        roles: user.roles || ['user']
      },
      JWT_SECRET,
      { expiresIn: '15m' }
    );
    
    res.json({ accessToken: newAccessToken });
  } catch (error) {
    res.status(401).json({ error: '令牌刷新失败' });
  }
});

2. 身份验证中间件：

// JWT认证中间件
function authenticateToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: '访问令牌缺失' });
  }
  
  jwt.verify(token, JWT_SECRET, (err, decoded) => {
    if (err) {
      return res.status(403).json({ error: '无效的访问令牌' });
    }
    
    req.user = decoded;
    next();
  });
}

// 可选认证中间件
function optionalAuth(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  
  if (token) {
    jwt.verify(token, JWT_SECRET, (err, decoded) => {
      if (!err) {
        req.user = decoded;
      }
    });
  }
  
  next();
}

// 使用认证中间件
app.get('/protected', authenticateToken, (req, res) => {
  res.json({
    message: '这是受保护的资源',
    user: req.user
  });
});

3. 基于角色的授权（RBAC）：

// 授权中间件
function authorize(roles = []) {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ error: '未认证' });
    }
    
    // 如果没有指定角色要求，则只需要认证
    if (roles.length === 0) {
      return next();
    }
    
    // 检查用户角色
    const userRoles = req.user.roles || [];
    const hasPermission = roles.some(role => userRoles.includes(role));
    
    if (!hasPermission) {
      return res.status(403).json({ error: '权限不足' });
    }
    
    next();
  };
}

// 权限检查函数
function checkPermission(resource, action) {
  return async (req, res, next) => {
    try {
      const userId = req.user.userId;
      const hasPermission = await userHasPermission(userId, resource, action);
      
      if (!hasPermission) {
        return res.status(403).json({ error: `无权限执行 ${action} 操作` });
      }
      
      next();
    } catch (error) {
      res.status(500).json({ error: '权限检查失败' });
    }
  };
}

// 使用授权中间件
app.get('/admin', authenticateToken, authorize(['admin']), (req, res) => {
  res.json({ message: '管理员专用接口' });
});

app.get('/users', authenticateToken, authorize(['admin', 'moderator']), (req, res) => {
  res.json({ message: '用户列表' });
});

app.delete('/posts/:id', 
  authenticateToken, 
  checkPermission('posts', 'delete'),
  (req, res) => {
    res.json({ message: '帖子已删除' });
  }
);

4. Session基础认证：

const session = require('express-session');
const MongoStore = require('connect-mongo');

// Session配置
app.use(session({
  secret: process.env.SESSION_SECRET || 'session-secret',
  resave: false,
  saveUninitialized: false,
  store: MongoStore.create({
    mongoUrl: 'mongodb://localhost:27017/myapp'
  }),
  cookie: {
    secure: process.env.NODE_ENV === 'production', // HTTPS
    httpOnly: true, // 防止XSS
    maxAge: 1000 * 60 * 60 * 24 // 24小时
  }
}));

// Session登录
app.post('/login-session', async (req, res) => {
  try {
    const { username, password } = req.body;
    
    const user = await getUserByUsername(username);
    if (!user || !await bcrypt.compare(password, user.password)) {
      return res.status(401).json({ error: '认证失败' });
    }
    
    // 设置session
    req.session.userId = user.id;
    req.session.username = user.username;
    req.session.roles = user.roles;
    
    res.json({ message: '登录成功', user: { id: user.id, username: user.username } });
  } catch (error) {
    res.status(500).json({ error: '登录失败' });
  }
});

// Session认证中间件
function requireAuth(req, res, next) {
  if (!req.session.userId) {
    return res.status(401).json({ error: '请先登录' });
  }
  
  req.user = {
    userId: req.session.userId,
    username: req.session.username,
    roles: req.session.roles
  };
  
  next();
}

// Session登出
app.post('/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) {
      return res.status(500).json({ error: '登出失败' });
    }
    
    res.clearCookie('connect.sid');
    res.json({ message: '登出成功' });
  });
});

5. OAuth 2.0集成（以Google为例）：

const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;

// Passport配置
passport.use(new GoogleStrategy({
  clientID: process.env.GOOGLE_CLIENT_ID,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET,
  callbackURL: "/auth/google/callback"
}, async (accessToken, refreshToken, profile, done) => {
  try {
    // 查找或创建用户
    let user = await getUserByGoogleId(profile.id);
    
    if (!user) {
      user = await createUser({
        googleId: profile.id,
        username: profile.displayName,
        email: profile.emails[0].value,
        avatar: profile.photos[0].value
      });
    }
    
    return done(null, user);
  } catch (error) {
    return done(error, null);
  }
}));

// Google OAuth路由
app.get('/auth/google',
  passport.authenticate('google', { scope: ['profile', 'email'] })
);

app.get('/auth/google/callback',
  passport.authenticate('google', { failureRedirect: '/login' }),
  (req, res) => {
    // 生成JWT令牌
    const token = jwt.sign(
      { userId: req.user.id, username: req.user.username },
      JWT_SECRET,
      { expiresIn: '1h' }
    );
    
    res.redirect(`/dashboard?token=${token}`);
  }
);

6. 安全最佳实践：

const rateLimit = require('express-rate-limit');
const helmet = require('helmet');

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

// 限流
const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分钟
  max: 5, // 最多5次尝试
  message: '登录尝试过于频繁，请稍后再试',
  standardHeaders: true,
  legacyHeaders: false
});

app.use('/login', loginLimiter);

// 密码复杂度验证
function validatePassword(password) {
  const minLength = 8;
  const hasUpperCase = /[A-Z]/.test(password);
  const hasLowerCase = /[a-z]/.test(password);
  const hasNumbers = /\d/.test(password);
  const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>]/.test(password);
  
  return password.length >= minLength && 
         hasUpperCase && 
         hasLowerCase && 
         hasNumbers && 
         hasSpecialChar;
}

// 登录日志
function logLoginAttempt(username, success, ip) {
  const logEntry = {
    username,
    success,
    ip,
    timestamp: new Date(),
    userAgent: req.headers['user-agent']
  };
  
  // 保存到日志系统
  console.log('登录尝试:', logEntry);
}

// 账户锁定机制
async function checkAccountLockout(username) {
  const attempts = await getFailedLoginAttempts(username);
  const maxAttempts = 5;
  const lockoutDuration = 30 * 60 * 1000; // 30分钟
  
  if (attempts.length >= maxAttempts) {
    const lastAttempt = attempts[attempts.length - 1];
    const timeSinceLastAttempt = Date.now() - lastAttempt.timestamp;
    
    if (timeSinceLastAttempt < lockoutDuration) {
      throw new Error('账户已被锁定，请稍后再试');
    }
  }
}

认证授权最佳实践：

• 使用强密码策略和密码哈希
• 实施多因素认证（2FA）
• 设置合理的令牌过期时间
• 实现刷新令牌机制
• 记录所有认证相关的操作日志
• 使用HTTPS传输敏感信息
• 实施限流和账户锁定机制
• 定期轮换密钥和令牌

How to handle CORS issues in Node.js?

考察点：跨域处理。

答案：

跨源资源共享（CORS）是一种机制，允许Web页面从不同域名访问资源。在Node.js应用中，需要正确配置CORS来确保前端应用能够安全地访问后端API。

CORS的工作原理：

• 浏览器在发送跨域请求前会发送预检请求（OPTIONS）
• 服务器通过响应头告诉浏览器是否允许实际请求
• 简单请求可能不会触发预检，但仍需要正确的响应头

1. 使用cors中间件（推荐）：

const express = require('express');
const cors = require('cors');

const app = express();

// 基本CORS设置 - 允许所有来源（开发环境）
app.use(cors());

// 自定义CORS配置
const corsOptions = {
  origin: [
    'http://localhost:3000',
    'https://myapp.com',
    'https://www.myapp.com'
  ],
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: [
    'Origin',
    'X-Requested-With',
    'Content-Type',
    'Accept',
    'Authorization',
    'Cache-Control'
  ],
  credentials: true, // 允许发送Cookie
  maxAge: 86400 // 预检请求缓存时间（秒）
};

app.use(cors(corsOptions));

// 动态CORS配置
const dynamicCors = (req, callback) => {
  let corsOptions;
  
  // 根据环境或请求动态设置
  if (process.env.NODE_ENV === 'development') {
    corsOptions = { origin: true }; // 允许所有来源
  } else {
    // 从数据库或配置中获取允许的域名
    const allowedOrigins = getAllowedOrigins();
    corsOptions = {
      origin: allowedOrigins,
      credentials: true
    };
  }
  
  callback(null, corsOptions);
};

app.use(cors(dynamicCors));

2. 手动实现CORS：

// 自定义CORS中间件
function customCors(req, res, next) {
  const allowedOrigins = [
    'http://localhost:3000',
    'https://myapp.com'
  ];
  
  const origin = req.headers.origin;
  
  // 检查来源是否被允许
  if (allowedOrigins.includes(origin)) {
    res.setHeader('Access-Control-Allow-Origin', origin);
  }
  
  // 设置允许的HTTP方法
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
  
  // 设置允许的请求头
  res.setHeader('Access-Control-Allow-Headers', 
    'Origin, X-Requested-With, Content-Type, Accept, Authorization');
  
  // 允许发送Cookie
  res.setHeader('Access-Control-Allow-Credentials', 'true');
  
  // 预检请求缓存时间
  res.setHeader('Access-Control-Max-Age', '86400');
  
  // 处理预检请求
  if (req.method === 'OPTIONS') {
    res.status(200).end();
    return;
  }
  
  next();
}

app.use(customCors);

// 更详细的CORS处理
function advancedCors(req, res, next) {
  const origin = req.headers.origin;
  const method = req.method;
  const requestHeaders = req.headers['access-control-request-headers'];
  
  // 日志记录
  console.log(`CORS请求: ${method} ${req.url} from ${origin}`);
  
  // 验证来源
  if (isOriginAllowed(origin)) {
    res.setHeader('Access-Control-Allow-Origin', origin);
    
    // 根据请求方法设置不同的头
    if (method === 'OPTIONS') {
      // 预检请求处理
      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
      
      if (requestHeaders) {
        res.setHeader('Access-Control-Allow-Headers', requestHeaders);
      }
      
      res.status(204).end();
      return;
    }
    
    // 实际请求处理
    res.setHeader('Access-Control-Allow-Credentials', 'true');
    
    // 暴露自定义响应头给前端
    res.setHeader('Access-Control-Expose-Headers', 'X-Total-Count, X-Page-Count');
  } else {
    // 不允许的来源
    res.status(403).json({ error: '不允许的跨域访问' });
    return;
  }
  
  next();
}

function isOriginAllowed(origin) {
  const allowedOrigins = process.env.ALLOWED_ORIGINS?.split(',') || [];
  return allowedOrigins.includes(origin) || process.env.NODE_ENV === 'development';
}

3. 特定路由的CORS设置：

const express = require('express');
const cors = require('cors');
const app = express();

// 为特定路由设置CORS
const apiCorsOptions = {
  origin: ['https://api-client.com', 'https://dashboard.com'],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  credentials: true
};

const publicCorsOptions = {
  origin: true, // 允许所有来源
  methods: ['GET'],
  credentials: false
};

// API路由使用严格的CORS设置
app.use('/api', cors(apiCorsOptions));

// 公共资源使用宽松的CORS设置
app.use('/public', cors(publicCorsOptions));

// 特定路由的自定义CORS
app.get('/api/public-data', cors({ origin: true }), (req, res) => {
  res.json({ message: '公共数据' });
});

// 需要认证的API使用严格CORS
app.use('/api/private', cors({
  origin: (origin, callback) => {
    // 动态验证来源
    validateOrigin(origin)
      .then(isValid => callback(null, isValid))
      .catch(err => callback(err));
  },
  credentials: true
}));

4. 处理复杂的CORS场景：

// 处理文件上传的CORS
const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

const uploadCors = cors({
  origin: ['https://upload-client.com'],
  methods: ['POST'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true
});

app.post('/api/upload', uploadCors, upload.single('file'), (req, res) => {
  res.json({ message: '文件上传成功', file: req.file });
});

// WebSocket的CORS处理
const { Server } = require('socket.io');
const http = require('http');

const server = http.createServer(app);
const io = new Server(server, {
  cors: {
    origin: ["https://socket-client.com", "http://localhost:3000"],
    methods: ["GET", "POST"],
    credentials: true
  }
});

io.on('connection', (socket) => {
  console.log('WebSocket连接建立');
  
  // 验证来源
  const origin = socket.handshake.headers.origin;
  if (!isOriginAllowed(origin)) {
    socket.disconnect();
    return;
  }
  
  socket.on('message', (data) => {
    // 处理消息
  });
});

5. CORS安全最佳实践：

// 环境相关的CORS配置
const getCorsOptions = () => {
  const baseOptions = {
    methods: ['GET', 'POST', 'PUT', 'DELETE'],
    allowedHeaders: [
      'Origin',
      'X-Requested-With',
      'Content-Type',
      'Accept',
      'Authorization'
    ],
    maxAge: 86400
  };
  
  if (process.env.NODE_ENV === 'production') {
    return {
      ...baseOptions,
      origin: process.env.ALLOWED_ORIGINS?.split(',') || [],
      credentials: true
    };
  } else {
    return {
      ...baseOptions,
      origin: true,
      credentials: true
    };
  }
};

app.use(cors(getCorsOptions()));

// CORS错误处理
app.use((err, req, res, next) => {
  if (err.message === 'CORS Error') {
    res.status(403).json({
      error: '跨域请求被拒绝',
      message: '请确认请求来源是否被允许'
    });
  } else {
    next(err);
  }
});

// CORS监控和日志
function corsLogger(req, res, next) {
  const origin = req.headers.origin;
  const method = req.method;
  
  // 记录跨域请求
  if (origin && origin !== req.headers.host) {
    console.log(`跨域请求: ${method} ${req.url} 来自 ${origin}`);
    
    // 可以添加到日志系统或监控系统
    logCorsRequest({
      method,
      url: req.url,
      origin,
      userAgent: req.headers['user-agent'],
      timestamp: new Date()
    });
  }
  
  next();
}

app.use(corsLogger);

6. 代理和反向代理的CORS处理：

// 使用http-proxy-middleware处理代理CORS
const { createProxyMiddleware } = require('http-proxy-middleware');

// API代理，自动处理CORS
const apiProxy = createProxyMiddleware('/api', {
  target: 'http://backend-server.com',
  changeOrigin: true,
  pathRewrite: {
    '^/api': '', // 重写路径
  },
  onProxyReq: (proxyReq, req, res) => {
    // 添加必要的头
    proxyReq.setHeader('Origin', 'http://your-frontend.com');
  },
  onProxyRes: (proxyRes, req, res) => {
    // 设置CORS头
    proxyRes.headers['Access-Control-Allow-Origin'] = req.headers.origin || '*';
    proxyRes.headers['Access-Control-Allow-Credentials'] = 'true';
  }
});

app.use(apiProxy);

CORS问题调试：

// CORS调试中间件
function corsDebug(req, res, next) {
  const origin = req.headers.origin;
  const method = req.method;
  
  console.log('=== CORS Debug Info ===');
  console.log('Origin:', origin);
  console.log('Method:', method);
  console.log('Headers:', req.headers);
  
  if (method === 'OPTIONS') {
    console.log('预检请求检测');
    console.log('Request Headers:', req.headers['access-control-request-headers']);
    console.log('Request Method:', req.headers['access-control-request-method']);
  }
  
  // 响应后记录CORS头
  const originalEnd = res.end;
  res.end = function(...args) {
    console.log('Response CORS Headers:');
    console.log('Access-Control-Allow-Origin:', res.getHeader('Access-Control-Allow-Origin'));
    console.log('Access-Control-Allow-Methods:', res.getHeader('Access-Control-Allow-Methods'));
    console.log('Access-Control-Allow-Headers:', res.getHeader('Access-Control-Allow-Headers'));
    console.log('========================');
    
    originalEnd.apply(this, args);
  };
  
  next();
}

// 在开发环境启用调试
if (process.env.NODE_ENV === 'development') {
  app.use(corsDebug);
}

常见CORS问题和解决方案：

• 预检请求失败：确保OPTIONS方法被正确处理
• Cookie不能发送：设置credentials: true和明确的origin
• 自定义头被拒绝：在allowedHeaders中添加自定义头
• 响应头无法访问：使用Access-Control-Expose-Headers暴露头部
• 开发环境vs生产环境：根据环境动态配置CORS策略

How to optimize the performance of Node.js applications?

考察点：性能优化策略。

答案：

Node.js应用性能优化是一个多层面的过程，涉及代码层面、架构设计、系统配置等多个方面。以下是主要的优化策略和技术：

1. 代码层面优化：

异步操作优化：

// 避免阻塞事件循环
// 错误做法 - 同步操作
const fs = require('fs');
const data = fs.readFileSync('large-file.txt'); // 阻塞

// 正确做法 - 异步操作
const fsPromises = require('fs').promises;
async function readFile() {
  try {
    const data = await fsPromises.readFile('large-file.txt');
    return data;
  } catch (error) {
    console.error(error);
  }
}

// 批处理异步操作
async function processMultipleFiles(filenames) {
  // 并行处理
  const results = await Promise.all(
    filenames.map(filename => fsPromises.readFile(filename))
  );
  return results;
}

// 限制并发数量
async function processWithConcurrencyLimit(items, limit = 5) {
  const results = [];
  
  for (let i = 0; i < items.length; i += limit) {
    const batch = items.slice(i, i + limit);
    const batchResults = await Promise.all(
      batch.map(item => processItem(item))
    );
    results.push(...batchResults);
  }
  
  return results;
}

内存管理优化：

// 避免内存泄漏
class DataProcessor {
  constructor() {
    this.cache = new Map();
    this.timers = new Set();
  }
  
  processData(data) {
    // 使用WeakMap避免内存泄漏
    const metadata = new WeakMap();
    metadata.set(data, { processed: true, timestamp: Date.now() });
    
    // 定期清理缓存
    this.scheduleCleanup();
    
    return this.transform(data);
  }
  
  scheduleCleanup() {
    const timer = setTimeout(() => {
      this.cleanup();
      this.timers.delete(timer);
    }, 60000);
    
    this.timers.add(timer);
  }
  
  cleanup() {
    // 清理过期缓存
    const now = Date.now();
    for (const [key, value] of this.cache.entries()) {
      if (now - value.timestamp > 300000) { // 5分钟过期
        this.cache.delete(key);
      }
    }
  }
  
  destroy() {
    // 清理资源
    this.cache.clear();
    this.timers.forEach(timer => clearTimeout(timer));
    this.timers.clear();
  }
}

// 流式处理大数据
const { Transform } = require('stream');

class DataTransform extends Transform {
  _transform(chunk, encoding, callback) {
    // 逐块处理，避免加载整个文件到内存
    const processed = this.processChunk(chunk);
    this.push(processed);
    callback();
  }
  
  processChunk(chunk) {
    // 处理数据块
    return chunk.toString().toUpperCase();
  }
}

2. 数据库优化：

// 连接池优化
const mysql = require('mysql2/promise');

const pool = mysql.createPool({
  host: 'localhost',
  user: 'username',
  password: 'password',
  database: 'mydb',
  waitForConnections: true,
  connectionLimit: 10,        // 连接池大小
  queueLimit: 0,
  acquireTimeout: 60000,      // 获取连接超时
  timeout: 60000,             // 查询超时
  reconnect: true,
  reconnectDelay: 2000
});

// 查询优化
class DatabaseService {
  async getUsersOptimized(page = 1, limit = 10) {
    // 使用索引字段查询
    // 限制返回字段
    // 分页查询
    const offset = (page - 1) * limit;
    
    const [rows] = await pool.execute(`
      SELECT id, username, email, created_at 
      FROM users 
      WHERE status = 'active'
      ORDER BY id 
      LIMIT ? OFFSET ?
    `, [limit, offset]);
    
    return rows;
  }
  
  async getUserWithCache(userId) {
    // 多级缓存策略
    let user = await this.getFromMemoryCache(`user:${userId}`);
    if (user) return user;
    
    user = await this.getFromRedisCache(`user:${userId}`);
    if (user) {
      this.setMemoryCache(`user:${userId}`, user, 300); // 5分钟
      return user;
    }
    
    user = await this.getUserFromDB(userId);
    if (user) {
      this.setRedisCache(`user:${userId}`, user, 3600); // 1小时
      this.setMemoryCache(`user:${userId}`, user, 300);
    }
    
    return user;
  }
}

3. 缓存策略：

const NodeCache = require('node-cache');
const Redis = require('redis');

// 多层缓存系统
class CacheManager {
  constructor() {
    // 内存缓存 - 最快，但容量小
    this.memoryCache = new NodeCache({ 
      stdTTL: 300,        // 默认5分钟过期
      checkperiod: 60,    // 每60秒检查过期
      maxKeys: 10000      // 最大key数量
    });
    
    // Redis缓存 - 较快，容量大
    this.redisClient = Redis.createClient();
  }
  
  async get(key) {
    // 先查内存缓存
    let value = this.memoryCache.get(key);
    if (value !== undefined) {
      return value;
    }
    
    // 再查Redis缓存
    const redisValue = await this.redisClient.get(key);
    if (redisValue) {
      value = JSON.parse(redisValue);
      // 回写内存缓存
      this.memoryCache.set(key, value, 300);
      return value;
    }
    
    return null;
  }
  
  async set(key, value, ttl = 3600) {
    // 同时设置内存和Redis缓存
    this.memoryCache.set(key, value, Math.min(ttl, 300));
    await this.redisClient.setex(key, ttl, JSON.stringify(value));
  }
  
  async invalidate(pattern) {
    // 删除匹配的缓存
    const keys = this.memoryCache.keys();
    keys.forEach(key => {
      if (key.includes(pattern)) {
        this.memoryCache.del(key);
      }
    });
    
    // Redis模式删除
    const redisKeys = await this.redisClient.keys(`*${pattern}*`);
    if (redisKeys.length > 0) {
      await this.redisClient.del(redisKeys);
    }
  }
}

4. HTTP优化：

const compression = require('compression');
const express = require('express');

const app = express();

// 启用Gzip压缩
app.use(compression({
  level: 6,                    // 压缩级别
  threshold: 1024,             // 只压缩大于1KB的响应
  filter: (req, res) => {
    // 自定义压缩过滤器
    if (req.headers['x-no-compression']) {
      return false;
    }
    return compression.filter(req, res);
  }
}));

// HTTP缓存
app.get('/api/static-data', (req, res) => {
  res.set({
    'Cache-Control': 'public, max-age=3600',  // 1小时缓存
    'ETag': generateETag(data),
    'Last-Modified': new Date().toUTCString()
  });
  
  // 检查条件请求
  if (req.fresh) {
    res.status(304).end();
    return;
  }
  
  res.json(data);
});

// 响应时间监控
function responseTime(req, res, next) {
  const startTime = process.hrtime();
  
  res.on('finish', () => {
    const [seconds, nanoseconds] = process.hrtime(startTime);
    const milliseconds = seconds * 1000 + nanoseconds / 1000000;
    
    res.set('X-Response-Time', `${milliseconds.toFixed(2)}ms`);
    
    // 记录慢请求
    if (milliseconds > 1000) {
      console.warn(`慢请求: ${req.method} ${req.url} - ${milliseconds.toFixed(2)}ms`);
    }
  });
  
  next();
}

app.use(responseTime);

5. 集群和负载均衡：

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const numWorkers = process.env.NODE_WORKERS || os.cpus().length;
  
  console.log(`启动 ${numWorkers} 个工作进程`);
  
  // 创建工作进程
  for (let i = 0; i < numWorkers; i++) {
    cluster.fork();
  }
  
  // 工作进程崩溃重启
  cluster.on('exit', (worker, code, signal) => {
    console.log(`工作进程 ${worker.process.pid} 退出`);
    cluster.fork();
  });
  
  // 优雅关闭
  process.on('SIGTERM', () => {
    console.log('收到SIGTERM信号，开始关闭工作进程...');
    
    for (const id in cluster.workers) {
      cluster.workers[id].kill();
    }
  });
} else {
  // 工作进程代码
  require('./app.js');
}

6. 性能监控和分析：

// 性能监控
class PerformanceMonitor {
  constructor() {
    this.metrics = {
      requests: 0,
      errors: 0,
      responseTime: [],
      memory: [],
      cpu: []
    };
    
    this.startMonitoring();
  }
  
  startMonitoring() {
    // 每秒收集系统指标
    setInterval(() => {
      this.collectMetrics();
    }, 1000);
    
    // 每分钟输出报告
    setInterval(() => {
      this.generateReport();
    }, 60000);
  }
  
  collectMetrics() {
    const memUsage = process.memoryUsage();
    const cpuUsage = process.cpuUsage();
    
    this.metrics.memory.push({
      rss: memUsage.rss,
      heapUsed: memUsage.heapUsed,
      heapTotal: memUsage.heapTotal,
      timestamp: Date.now()
    });
    
    this.metrics.cpu.push({
      user: cpuUsage.user,
      system: cpuUsage.system,
      timestamp: Date.now()
    });
    
    // 保持最近1小时的数据
    const oneHourAgo = Date.now() - 3600000;
    this.metrics.memory = this.metrics.memory.filter(m => m.timestamp > oneHourAgo);
    this.metrics.cpu = this.metrics.cpu.filter(c => c.timestamp > oneHourAgo);
    this.metrics.responseTime = this.metrics.responseTime.filter(r => r.timestamp > oneHourAgo);
  }
  
  recordRequest(responseTime, isError = false) {
    this.metrics.requests++;
    if (isError) this.metrics.errors++;
    
    this.metrics.responseTime.push({
      time: responseTime,
      timestamp: Date.now()
    });
  }
  
  generateReport() {
    const avgResponseTime = this.metrics.responseTime.length > 0
      ? this.metrics.responseTime.reduce((sum, r) => sum + r.time, 0) / this.metrics.responseTime.length
      : 0;
    
    const errorRate = this.metrics.requests > 0
      ? (this.metrics.errors / this.metrics.requests) * 100
      : 0;
    
    console.log('=== 性能报告 ===');
    console.log(`请求总数: ${this.metrics.requests}`);
    console.log(`错误率: ${errorRate.toFixed(2)}%`);
    console.log(`平均响应时间: ${avgResponseTime.toFixed(2)}ms`);
    console.log(`内存使用: ${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(2)}MB`);
  }
}

const monitor = new PerformanceMonitor();

// 集成到Express中间件
function performanceMiddleware(req, res, next) {
  const start = process.hrtime();
  
  res.on('finish', () => {
    const [seconds, nanoseconds] = process.hrtime(start);
    const responseTime = seconds * 1000 + nanoseconds / 1000000;
    const isError = res.statusCode >= 400;
    
    monitor.recordRequest(responseTime, isError);
  });
  
  next();
}

app.use(performanceMiddleware);

7. 其他优化技巧：

// JSON序列化优化
const fastJsonStringify = require('fast-json-stringify');

const stringify = fastJsonStringify({
  title: 'User Schema',
  type: 'object',
  properties: {
    id: { type: 'number' },
    username: { type: 'string' },
    email: { type: 'string' }
  }
});

// 比JSON.stringify快2-5倍
app.get('/api/users', async (req, res) => {
  const users = await getUsersFromDB();
  res.set('Content-Type', 'application/json');
  res.send(stringify(users));
});

// 定时器优化
class TimerManager {
  constructor() {
    this.timers = new Set();
  }
  
  setTimeout(callback, delay) {
    const timer = setTimeout(() => {
      callback();
      this.timers.delete(timer);
    }, delay);
    
    this.timers.add(timer);
    return timer;
  }
  
  clearAll() {
    this.timers.forEach(timer => clearTimeout(timer));
    this.timers.clear();
  }
}

// 避免创建不必要的对象
function optimizedHandler(req, res) {
  // 重用对象
  const response = {
    success: true,
    data: null,
    timestamp: Date.now()
  };
  
  // 避免在循环中创建对象
  const items = [];
  for (let i = 0; i < data.length; i++) {
    // 直接操作现有对象而不是创建新对象
    items.push(processItem(data[i]));
  }
  
  response.data = items;
  res.json(response);
}

性能优化最佳实践：

• 使用性能分析工具（如clinic.js、0x）
• 监控关键指标（响应时间、内存使用、CPU使用率）
• 实施适当的缓存策略
• 优化数据库查询和连接
• 使用CDN和静态资源优化
• 启用HTTP/2和压缩
• 定期进行性能测试和调优

How to implement caching mechanisms in Node.js?

考察点：缓存策略设计。

答案：

缓存是提高Node.js应用性能的重要手段，通过存储频繁访问的数据来减少数据库查询和计算开销。Node.js中可以实现多种类型的缓存机制。

1. 内存缓存（Memory Cache）：

const NodeCache = require('node-cache');

// 基本内存缓存
class MemoryCache {
  constructor(options = {}) {
    this.cache = new NodeCache({
      stdTTL: options.ttl || 600,      // 默认10分钟过期
      checkperiod: options.checkperiod || 60, // 每60秒检查过期
      useClones: false,                 // 不克隆对象，提高性能
      maxKeys: options.maxKeys || 10000 // 最大key数量
    });
    
    this.stats = {
      hits: 0,
      misses: 0,
      sets: 0
    };
  }
  
  get(key) {
    const value = this.cache.get(key);
    if (value !== undefined) {
      this.stats.hits++;
      return value;
    }
    this.stats.misses++;
    return null;
  }
  
  set(key, value, ttl) {
    this.stats.sets++;
    return this.cache.set(key, value, ttl);
  }
  
  del(key) {
    return this.cache.del(key);
  }
  
  flush() {
    this.cache.flushAll();
    this.stats = { hits: 0, misses: 0, sets: 0 };
  }
  
  getStats() {
    const hitRate = this.stats.hits + this.stats.misses > 0 
      ? (this.stats.hits / (this.stats.hits + this.stats.misses) * 100).toFixed(2)
      : 0;
    
    return {
      ...this.stats,
      hitRate: `${hitRate}%`,
      keys: this.cache.keys().length
    };
  }
}

const memoryCache = new MemoryCache({ ttl: 300, maxKeys: 5000 });

// 使用示例
async function getUserById(userId) {
  const cacheKey = `user:${userId}`;
  
  // 先从缓存获取
  let user = memoryCache.get(cacheKey);
  if (user) {
    console.log('从内存缓存获取用户');
    return user;
  }
  
  // 缓存未命中，从数据库获取
  user = await database.getUserById(userId);
  if (user) {
    memoryCache.set(cacheKey, user, 600); // 缓存10分钟
  }
  
  return user;
}

2. Redis分布式缓存：

const Redis = require('redis');
const client = Redis.createClient({
  host: 'localhost',
  port: 6379,
  db: 0,
  maxRetriesPerRequest: 3
});

class RedisCache {
  constructor(redisClient) {
    this.client = redisClient;
    this.prefix = 'cache:';
  }
  
  async get(key) {
    try {
      const value = await this.client.get(this.prefix + key);
      return value ? JSON.parse(value) : null;
    } catch (error) {
      console.error('Redis获取缓存错误:', error);
      return null;
    }
  }
  
  async set(key, value, ttl = 3600) {
    try {
      const serialized = JSON.stringify(value);
      if (ttl > 0) {
        await this.client.setex(this.prefix + key, ttl, serialized);
      } else {
        await this.client.set(this.prefix + key, serialized);
      }
      return true;
    } catch (error) {
      console.error('Redis设置缓存错误:', error);
      return false;
    }
  }
  
  async del(key) {
    try {
      return await this.client.del(this.prefix + key);
    } catch (error) {
      console.error('Redis删除缓存错误:', error);
      return false;
    }
  }
  
  async exists(key) {
    try {
      return await this.client.exists(this.prefix + key);
    } catch (error) {
      console.error('Redis检查缓存错误:', error);
      return false;
    }
  }
  
  async increment(key, value = 1, ttl = 3600) {
    try {
      const result = await this.client.incrby(this.prefix + key, value);
      if (ttl > 0) {
        await this.client.expire(this.prefix + key, ttl);
      }
      return result;
    } catch (error) {
      console.error('Redis递增缓存错误:', error);
      return null;
    }
  }
  
  async mget(keys) {
    try {
      const prefixedKeys = keys.map(key => this.prefix + key);
      const values = await this.client.mget(prefixedKeys);
      return values.map(value => value ? JSON.parse(value) : null);
    } catch (error) {
      console.error('Redis批量获取缓存错误:', error);
      return keys.map(() => null);
    }
  }
  
  async mset(pairs, ttl = 3600) {
    try {
      const pipeline = this.client.pipeline();
      
      for (const [key, value] of pairs) {
        const serialized = JSON.stringify(value);
        if (ttl > 0) {
          pipeline.setex(this.prefix + key, ttl, serialized);
        } else {
          pipeline.set(this.prefix + key, serialized);
        }
      }
      
      await pipeline.exec();
      return true;
    } catch (error) {
      console.error('Redis批量设置缓存错误:', error);
      return false;
    }
  }
}

const redisCache = new RedisCache(client);

3. 多层缓存策略：

class MultiLayerCache {
  constructor(options = {}) {
    // L1缓存：内存缓存（最快，容量小）
    this.l1Cache = new NodeCache({
      stdTTL: options.l1Ttl || 300,     // 5分钟
      maxKeys: options.l1MaxKeys || 1000
    });
    
    // L2缓存：Redis缓存（较快，容量大）
    this.l2Cache = new RedisCache(client);
    
    this.stats = {
      l1Hits: 0,
      l2Hits: 0,
      misses: 0
    };
  }
  
  async get(key) {
    // 先查L1缓存
    let value = this.l1Cache.get(key);
    if (value !== undefined) {
      this.stats.l1Hits++;
      return value;
    }
    
    // 再查L2缓存
    value = await this.l2Cache.get(key);
    if (value !== null) {
      this.stats.l2Hits++;
      // 回写L1缓存
      this.l1Cache.set(key, value, 300);
      return value;
    }
    
    this.stats.misses++;
    return null;
  }
  
  async set(key, value, ttl = { l1: 300, l2: 3600 }) {
    // 同时设置两层缓存
    this.l1Cache.set(key, value, ttl.l1);
    await this.l2Cache.set(key, value, ttl.l2);
  }
  
  async invalidate(key) {
    this.l1Cache.del(key);
    await this.l2Cache.del(key);
  }
  
  async invalidatePattern(pattern) {
    // L1缓存模式删除
    const l1Keys = this.l1Cache.keys();
    l1Keys.forEach(key => {
      if (key.includes(pattern)) {
        this.l1Cache.del(key);
      }
    });
    
    // L2缓存模式删除
    const l2Keys = await client.keys(`cache:*${pattern}*`);
    if (l2Keys.length > 0) {
      const keysToDelete = l2Keys.map(key => key.replace('cache:', ''));
      await Promise.all(keysToDelete.map(key => this.l2Cache.del(key)));
    }
  }
  
  getStats() {
    const totalRequests = this.stats.l1Hits + this.stats.l2Hits + this.stats.misses;
    return {
      ...this.stats,
      totalRequests,
      l1HitRate: totalRequests > 0 ? ((this.stats.l1Hits / totalRequests) * 100).toFixed(2) + '%' : '0%',
      l2HitRate: totalRequests > 0 ? ((this.stats.l2Hits / totalRequests) * 100).toFixed(2) + '%' : '0%',
      overallHitRate: totalRequests > 0 ? (((this.stats.l1Hits + this.stats.l2Hits) / totalRequests) * 100).toFixed(2) + '%' : '0%'
    };
  }
}

const multiCache = new MultiLayerCache();

4. 缓存装饰器和中间件：

// 缓存装饰器
function cached(ttl = 3600, keyGenerator) {
  return function(target, propertyName, descriptor) {
    const originalMethod = descriptor.value;
    
    descriptor.value = async function(...args) {
      const key = keyGenerator ? keyGenerator(...args) : `${propertyName}:${JSON.stringify(args)}`;
      
      // 尝试从缓存获取
      let result = await multiCache.get(key);
      if (result !== null) {
        return result;
      }
      
      // 执行原方法
      result = await originalMethod.apply(this, args);
      
      // 缓存结果
      if (result !== null && result !== undefined) {
        await multiCache.set(key, result, { l1: ttl / 10, l2: ttl });
      }
      
      return result;
    };
  };
}

// 使用缓存装饰器
class UserService {
  @cached(600, (userId) => `user:${userId}`)
  async getUserById(userId) {
    return await database.getUserById(userId);
  }
  
  @cached(300, (status, page) => `users:${status}:page:${page}`)
  async getUsersByStatus(status, page = 1) {
    return await database.getUsersByStatus(status, page);
  }
}

// Express缓存中间件
function cacheMiddleware(ttl = 300) {
  return async (req, res, next) => {
    if (req.method !== 'GET') {
      return next();
    }
    
    const key = `http:${req.originalUrl || req.url}`;
    
    try {
      const cached = await multiCache.get(key);
      if (cached) {
        res.set('X-Cache', 'HIT');
        return res.json(cached);
      }
      
      // 重写res.json来缓存响应
      const originalJson = res.json;
      res.json = function(data) {
        multiCache.set(key, data, { l1: ttl / 10, l2: ttl });
        res.set('X-Cache', 'MISS');
        originalJson.call(this, data);
      };
      
      next();
    } catch (error) {
      console.error('缓存中间件错误:', error);
      next();
    }
  };
}

// 使用缓存中间件
app.get('/api/users', cacheMiddleware(600), async (req, res) => {
  const users = await userService.getAllUsers();
  res.json(users);
});

5. 缓存失效策略：

class CacheInvalidationService {
  constructor(cache) {
    this.cache = cache;
    this.dependencies = new Map(); // key -> Set of dependent keys
  }
  
  // 设置缓存依赖关系
  addDependency(key, dependsOn) {
    if (!this.dependencies.has(dependsOn)) {
      this.dependencies.set(dependsOn, new Set());
    }
    this.dependencies.get(dependsOn).add(key);
  }
  
  // 级联删除依赖的缓存
  async invalidateWithDependencies(key) {
    await this.cache.invalidate(key);
    
    const dependents = this.dependencies.get(key);
    if (dependents) {
      for (const dependent of dependents) {
        await this.invalidateWithDependencies(dependent);
      }
      this.dependencies.delete(key);
    }
  }
  
  // 基于标签的缓存失效
  async invalidateByTag(tag) {
    await this.cache.invalidatePattern(tag);
  }
  
  // 时间窗口缓存失效
  scheduleInvalidation(key, delay) {
    setTimeout(async () => {
      await this.cache.invalidate(key);
    }, delay);
  }
}

// 使用示例
const cacheInvalidator = new CacheInvalidationService(multiCache);

async function updateUser(userId, userData) {
  // 更新数据库
  const updatedUser = await database.updateUser(userId, userData);
  
  // 失效相关缓存
  await cacheInvalidator.invalidateWithDependencies(`user:${userId}`);
  await cacheInvalidator.invalidateByTag(`user_list`);
  
  return updatedUser;
}

6. 缓存预热和刷新：

class CacheWarmer {
  constructor(cache) {
    this.cache = cache;
    this.warmupTasks = new Map();
  }
  
  // 注册预热任务
  registerWarmupTask(key, loader, interval = 3600000) { // 默认1小时
    this.warmupTasks.set(key, { loader, interval });
  }
  
  // 执行预热
  async warmup(keys = []) {
    const tasksToWarm = keys.length > 0 
      ? keys.filter(key => this.warmupTasks.has(key))
      : Array.from(this.warmupTasks.keys());
    
    console.log(`开始预热缓存，共${tasksToWarm.length}个任务`);
    
    const results = await Promise.allSettled(
      tasksToWarm.map(async (key) => {
        const { loader } = this.warmupTasks.get(key);
        try {
          const data = await loader();
          await this.cache.set(key, data);
          console.log(`缓存预热完成: ${key}`);
        } catch (error) {
          console.error(`缓存预热失败: ${key}`, error);
        }
      })
    );
    
    const successful = results.filter(r => r.status === 'fulfilled').length;
    console.log(`缓存预热完成: ${successful}/${tasksToWarm.length}`);
  }
  
  // 启动定期刷新
  startPeriodicRefresh() {
    for (const [key, { loader, interval }] of this.warmupTasks) {
      setInterval(async () => {
        try {
          const data = await loader();
          await this.cache.set(key, data);
          console.log(`定期刷新缓存: ${key}`);
        } catch (error) {
          console.error(`定期刷新失败: ${key}`, error);
        }
      }, interval);
    }
  }
}

const cacheWarmer = new CacheWarmer(multiCache);

// 注册预热任务
cacheWarmer.registerWarmupTask('popular_products', async () => {
  return await database.getPopularProducts();
}, 1800000); // 30分钟刷新

cacheWarmer.registerWarmupTask('site_config', async () => {
  return await database.getSiteConfig();
}, 3600000); // 1小时刷新

// 应用启动时预热
cacheWarmer.warmup().then(() => {
  console.log('初始缓存预热完成');
  cacheWarmer.startPeriodicRefresh();
});

缓存最佳实践：

• 选择合适的缓存策略（LRU、TTL、分层缓存）
• 合理设置过期时间
• 实施缓存预热和定期刷新
• 监控缓存命中率和性能
• 处理缓存雪崩、击穿和穿透问题
• 设计合理的缓存Key命名规范
• 实施缓存一致性保证机制

How to implement WebSocket communication in Node.js?

考察点：实时通信实现。

答案：

WebSocket是一种在单个TCP连接上进行全双工通信的协议，非常适合实时应用如聊天室、在线游戏、实时数据推送等。Node.js提供了多种实现WebSocket通信的方式。

1. 使用原生ws库：

const WebSocket = require('ws');
const http = require('http');

// 创建HTTP服务器
const server = http.createServer();

// 创建WebSocket服务器
const wss = new WebSocket.Server({ server });

// 连接处理
wss.on('connection', (ws, req) => {
  console.log('新的WebSocket连接');
  console.log('客户端IP:', req.connection.remoteAddress);
  
  // 发送欢迎消息
  ws.send(JSON.stringify({
    type: 'welcome',
    message: '连接成功',
    timestamp: Date.now()
  }));
  
  // 消息处理
  ws.on('message', (message) => {
    try {
      const data = JSON.parse(message);
      console.log('接收到消息:', data);
      
      // 处理不同类型的消息
      switch (data.type) {
        case 'chat':
          handleChatMessage(ws, data);
          break;
        case 'ping':
          ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() }));
          break;
        default:
          ws.send(JSON.stringify({ type: 'error', message: '未知消息类型' }));
      }
    } catch (error) {
      console.error('消息解析错误:', error);
      ws.send(JSON.stringify({ type: 'error', message: '消息格式错误' }));
    }
  });
  
  // 连接关闭
  ws.on('close', (code, reason) => {
    console.log('WebSocket连接关闭:', code, reason);
  });
  
  // 错误处理
  ws.on('error', (error) => {
    console.error('WebSocket错误:', error);
  });
});

function handleChatMessage(ws, data) {
  const message = {
    type: 'chat',
    user: data.user,
    message: data.message,
    timestamp: Date.now()
  };
  
  // 广播消息给所有连接的客户端
  wss.clients.forEach((client) => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(JSON.stringify(message));
    }
  });
}

server.listen(3000, () => {
  console.log('WebSocket服务器运行在端口3000');
});

2. 使用Socket.io（推荐）：

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
  cors: {
    origin: "http://localhost:3000",
    methods: ["GET", "POST"]
  }
});

// 用户管理
const users = new Map();
const rooms = new Map();

// 中间件 - 身份验证
io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  
  if (token) {
    // 验证JWT token
    try {
      const user = jwt.verify(token, JWT_SECRET);
      socket.userId = user.id;
      socket.username = user.username;
      next();
    } catch (error) {
      next(new Error('Authentication error'));
    }
  } else {
    next(new Error('Authentication error'));
  }
});

// 连接处理
io.on('connection', (socket) => {
  console.log(`用户 ${socket.username} 连接成功`);
  
  // 添加用户到在线列表
  users.set(socket.id, {
    id: socket.userId,
    username: socket.username,
    socketId: socket.id,
    joinedAt: Date.now()
  });
  
  // 广播在线用户列表
  io.emit('users:online', Array.from(users.values()));
  
  // 加入房间
  socket.on('room:join', (roomId) => {
    socket.join(roomId);
    
    // 更新房间信息
    if (!rooms.has(roomId)) {
      rooms.set(roomId, { users: new Set(), messages: [] });
    }
    rooms.get(roomId).users.add(socket.id);
    
    // 通知房间其他用户
    socket.to(roomId).emit('user:joined', {
      username: socket.username,
      message: `${socket.username} 加入了房间`
    });
    
    // 发送房间历史消息
    const roomData = rooms.get(roomId);
    socket.emit('room:messages', roomData.messages.slice(-50)); // 最近50条消息
  });
  
  // 离开房间
  socket.on('room:leave', (roomId) => {
    socket.leave(roomId);
    
    if (rooms.has(roomId)) {
      rooms.get(roomId).users.delete(socket.id);
      
      // 通知房间其他用户
      socket.to(roomId).emit('user:left', {
        username: socket.username,
        message: `${socket.username} 离开了房间`
      });
    }
  });
  
  // 处理聊天消息
  socket.on('chat:message', (data) => {
    const message = {
      id: generateMessageId(),
      user: socket.username,
      userId: socket.userId,
      content: data.message,
      roomId: data.roomId,
      timestamp: Date.now()
    };
    
    // 保存消息到房间
    if (rooms.has(data.roomId)) {
      rooms.get(data.roomId).messages.push(message);
      
      // 限制消息数量
      const roomMessages = rooms.get(data.roomId).messages;
      if (roomMessages.length > 1000) {
        roomMessages.splice(0, roomMessages.length - 1000);
      }
    }
    
    // 广播消息到房间
    io.to(data.roomId).emit('chat:message', message);
    
    // 保存到数据库（可选）
    saveChatMessage(message).catch(console.error);
  });
  
  // 处理私聊
  socket.on('private:message', (data) => {
    const targetUser = Array.from(users.values())
      .find(user => user.username === data.to);
    
    if (targetUser) {
      const message = {
        from: socket.username,
        to: data.to,
        content: data.message,
        timestamp: Date.now()
      };
      
      // 发送给目标用户
      io.to(targetUser.socketId).emit('private:message', message);
      
      // 确认发送给发送者
      socket.emit('private:sent', message);
    } else {
      socket.emit('error', { message: '用户不在线' });
    }
  });
  
  // 输入状态
  socket.on('typing:start', (roomId) => {
    socket.to(roomId).emit('user:typing', {
      username: socket.username,
      typing: true
    });
  });
  
  socket.on('typing:stop', (roomId) => {
    socket.to(roomId).emit('user:typing', {
      username: socket.username,
      typing: false
    });
  });
  
  // 断线处理
  socket.on('disconnect', (reason) => {
    console.log(`用户 ${socket.username} 断开连接:`, reason);
    
    // 从在线用户列表移除
    users.delete(socket.id);
    
    // 从所有房间移除
    rooms.forEach((room, roomId) => {
      if (room.users.has(socket.id)) {
        room.users.delete(socket.id);
        socket.to(roomId).emit('user:left', {
          username: socket.username,
          message: `${socket.username} 离开了房间`
        });
      }
    });
    
    // 更新在线用户列表
    io.emit('users:online', Array.from(users.values()));
  });
});

3. WebSocket集群和扩展性：

const cluster = require('cluster');
const redis = require('redis');
const { createAdapter } = require('@socket.io/redis-adapter');

if (cluster.isMaster) {
  // 主进程创建工作进程
  const numWorkers = require('os').cpus().length;
  
  for (let i = 0; i < numWorkers; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  // 工作进程
  const app = express();
  const server = http.createServer(app);
  const io = socketIo(server);
  
  // Redis适配器用于多进程通信
  const pubClient = redis.createClient({ host: 'localhost', port: 6379 });
  const subClient = pubClient.duplicate();
  
  io.adapter(createAdapter(pubClient, subClient));
  
  // Socket.io逻辑
  io.on('connection', (socket) => {
    // ... 连接处理逻辑
  });
  
  server.listen(3000 + cluster.worker.id);
}

4. 高级WebSocket功能：

// 心跳检测
class WebSocketManager {
  constructor() {
    this.connections = new Map();
    this.heartbeatInterval = 30000; // 30秒心跳
    this.startHeartbeat();
  }
  
  addConnection(socket) {
    const connectionInfo = {
      socket,
      lastPing: Date.now(),
      isAlive: true
    };
    
    this.connections.set(socket.id, connectionInfo);
    
    // 设置pong处理
    socket.on('pong', () => {
      connectionInfo.lastPing = Date.now();
      connectionInfo.isAlive = true;
    });
  }
  
  removeConnection(socketId) {
    this.connections.delete(socketId);
  }
  
  startHeartbeat() {
    setInterval(() => {
      this.connections.forEach((conn, socketId) => {
        if (!conn.isAlive) {
          // 连接已死，终止连接
          conn.socket.terminate();
          this.connections.delete(socketId);
          return;
        }
        
        // 检查是否超时
        const timeSinceLastPing = Date.now() - conn.lastPing;
        if (timeSinceLastPing > this.heartbeatInterval * 2) {
          conn.isAlive = false;
          conn.socket.ping();
        }
      });
    }, this.heartbeatInterval);
  }
  
  broadcast(message) {
    this.connections.forEach((conn) => {
      if (conn.socket.readyState === WebSocket.OPEN) {
        conn.socket.send(JSON.stringify(message));
      }
    });
  }
  
  sendToUser(userId, message) {
    const connection = Array.from(this.connections.values())
      .find(conn => conn.socket.userId === userId);
    
    if (connection && connection.socket.readyState === WebSocket.OPEN) {
      connection.socket.send(JSON.stringify(message));
      return true;
    }
    return false;
  }
}

const wsManager = new WebSocketManager();

5. WebSocket安全性：

const rateLimit = require('express-rate-limit');

// 连接速率限制
const connectionLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分钟
  max: 10, // 每个IP最多10个连接
  message: '连接过于频繁，请稍后再试'
});

app.use('/socket.io/', connectionLimiter);

// WebSocket身份验证和授权
io.use(async (socket, next) => {
  try {
    const token = socket.handshake.auth.token;
    
    if (!token) {
      throw new Error('No token provided');
    }
    
    // 验证JWT
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // 检查用户权限
    const user = await getUserById(decoded.userId);
    if (!user || user.status !== 'active') {
      throw new Error('User not active');
    }
    
    socket.user = user;
    next();
  } catch (error) {
    next(new Error('Authentication failed'));
  }
});

// 消息验证和清理
function validateMessage(message) {
  if (!message || typeof message !== 'string') {
    throw new Error('Invalid message format');
  }
  
  if (message.length > 1000) {
    throw new Error('Message too long');
  }
  
  // 过滤敏感内容
  return sanitizeHtml(message);
}

// WebSocket消息加密
const crypto = require('crypto');

function encryptMessage(message, key) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipher('aes-256-cbc', key, iv);
  let encrypted = cipher.update(message, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  return iv.toString('hex') + ':' + encrypted;
}

function decryptMessage(encryptedMessage, key) {
  const parts = encryptedMessage.split(':');
  const iv = Buffer.from(parts[0], 'hex');
  const encrypted = parts[1];
  const decipher = crypto.createDecipher('aes-256-cbc', key, iv);
  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  return decrypted;
}

6. 客户端示例：

// 浏览器客户端
const socket = io('http://localhost:3000', {
  auth: {
    token: localStorage.getItem('jwt_token')
  }
});

socket.on('connect', () => {
  console.log('连接成功');
});

socket.on('chat:message', (message) => {
  displayMessage(message);
});

socket.on('disconnect', () => {
  console.log('连接断开');
});

// 发送消息
function sendMessage(roomId, message) {
  socket.emit('chat:message', {
    roomId,
    message
  });
}

// 加入房间
function joinRoom(roomId) {
  socket.emit('room:join', roomId);
}

WebSocket最佳实践：

• 实施适当的身份验证和授权
• 使用心跳检测维持连接健康
• 限制连接数量和消息频率
• 验证和清理所有输入数据
• 实施消息持久化和离线消息
• 使用集群和Redis适配器支持扩展
• 监控连接状态和性能指标
• 优雅处理连接断开和重连

How does memory management work in Node.js? How to avoid memory leaks?

考察点：内存管理。

答案：

Node.js的内存管理基于V8引擎的垃圾回收机制。了解内存管理原理和常见的内存泄漏场景对于开发高性能的Node.js应用至关重要。

1. V8内存结构：

// 查看内存使用情况
function getMemoryUsage() {
  const usage = process.memoryUsage();
  
  return {
    // 常驻内存集，包含堆、代码段、栈
    rss: `${Math.round(usage.rss / 1024 / 1024 * 100) / 100} MB`,
    
    // V8堆的总分配内存
    heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024 * 100) / 100} MB`,
    
    // V8堆的已使用内存
    heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024 * 100) / 100} MB`,
    
    // 外部C++对象绑定到JavaScript对象的内存
    external: `${Math.round(usage.external / 1024 / 1024 * 100) / 100} MB`,
    
    // ArrayBuffer分配的内存
    arrayBuffers: `${Math.round(usage.arrayBuffers / 1024 / 1024 * 100) / 100} MB`
  };
}

// 定期监控内存使用
setInterval(() => {
  console.log('内存使用情况:', getMemoryUsage());
}, 10000);

// V8堆统计信息
if (global.gc) {
  global.gc(); // 手动触发垃圾回收
  const heapStats = v8.getHeapStatistics();
  console.log('堆统计:', heapStats);
}

2. 垃圾回收机制：

const v8 = require('v8');

// 分代垃圾回收
class MemoryManager {
  constructor() {
    this.youngGeneration = new Map(); // 新生代 - Scavenge算法
    this.oldGeneration = new Map();   // 老生代 - Mark-Sweep算法
  }
  
  // 监控垃圾回收
  startGCMonitoring() {
    // 在Node.js启动时添加 --expose-gc 标志
    if (global.gc) {
      const PerformanceObserver = require('perf_hooks').PerformanceObserver;
      
      const obs = new PerformanceObserver((list) => {
        const entries = list.getEntries();
        entries.forEach((entry) => {
          console.log(`GC ${entry.name}: ${entry.duration.toFixed(2)}ms`);
        });
      });
      
      obs.observe({ entryTypes: ['gc'] });
    }
  }
  
  // 获取堆快照
  async takeHeapSnapshot() {
    const heapSnapshot = v8.getHeapSnapshot();
    const chunks = [];
    
    for await (const chunk of heapSnapshot) {
      chunks.push(chunk);
    }
    
    return Buffer.concat(chunks);
  }
  
  // 内存压力检测
  checkMemoryPressure() {
    const usage = process.memoryUsage();
    const heapUsedMB = usage.heapUsed / 1024 / 1024;
    const heapTotalMB = usage.heapTotal / 1024 / 1024;
    
    const heapUsagePercent = (heapUsedMB / heapTotalMB) * 100;
    
    if (heapUsagePercent > 80) {
      console.warn('内存使用率过高:', heapUsagePercent.toFixed(2) + '%');
      
      // 触发垃圾回收
      if (global.gc) {
        global.gc();
      }
      
      return true;
    }
    
    return false;
  }
}

const memoryManager = new MemoryManager();
memoryManager.startGCMonitoring();

3. 常见内存泄漏场景及解决方案：

场景1：事件监听器泄漏

// 错误示例 - 事件监听器累积
class BadEventHandler {
  constructor() {
    setInterval(() => {
      process.on('data', this.handleData.bind(this)); // 每次都添加新监听器
    }, 1000);
  }
  
  handleData(data) {
    console.log('处理数据:', data);
  }
}

// 正确示例 - 正确管理事件监听器
class GoodEventHandler {
  constructor() {
    this.handleData = this.handleData.bind(this);
    this.isListening = false;
    this.setupListener();
  }
  
  setupListener() {
    if (!this.isListening) {
      process.on('data', this.handleData);
      this.isListening = true;
    }
  }
  
  handleData(data) {
    console.log('处理数据:', data);
  }
  
  cleanup() {
    if (this.isListening) {
      process.removeListener('data', this.handleData);
      this.isListening = false;
    }
  }
}

// EventEmitter最大监听器数量检查
const EventEmitter = require('events');

class SafeEmitter extends EventEmitter {
  constructor() {
    super();
    this.setMaxListeners(10); // 设置最大监听器数量
  }
  
  addSafeListener(event, listener) {
    const currentCount = this.listenerCount(event);
    
    if (currentCount >= this.getMaxListeners()) {
      console.warn(`事件 ${event} 监听器数量过多: ${currentCount}`);
      return false;
    }
    
    this.on(event, listener);
    return true;
  }
}

场景2：闭包和变量引用泄漏

// 错误示例 - 闭包导致的内存泄漏
class BadClosureHandler {
  constructor() {
    this.cache = new Map();
    this.largeData = new Array(1000000).fill('data');
  }
  
  createHandler(id) {
    // 闭包引用了整个this，包括largeData
    return () => {
      console.log('处理ID:', id);
      return this.largeData.length; // 引用大对象
    };
  }
}

// 正确示例 - 避免不必要的闭包引用
class GoodClosureHandler {
  constructor() {
    this.cache = new Map();
    this.largeData = new Array(1000000).fill('data');
  }
  
  createHandler(id) {
    const dataLength = this.largeData.length; // 只保存需要的值
    
    // 闭包只引用必要的变量
    return () => {
      console.log('处理ID:', id);
      return dataLength;
    };
  }
  
  // 使用WeakMap避免循环引用
  createWeakHandler(obj) {
    const handlers = new WeakMap();
    
    return (key) => {
      if (!handlers.has(obj)) {
        handlers.set(obj, new Map());
      }
      
      const objHandlers = handlers.get(obj);
      if (!objHandlers.has(key)) {
        objHandlers.set(key, () => {
          console.log('处理对象:', obj.id, '键:', key);
        });
      }
      
      return objHandlers.get(key);
    };
  }
}

场景3：定时器泄漏

// 错误示例 - 定时器没有清理
class BadTimerHandler {
  constructor() {
    this.data = new Array(100000).fill('data');
    
    setInterval(() => {
      this.processData();
    }, 1000); // 定时器持有对this的引用
  }
  
  processData() {
    console.log('处理数据:', this.data.length);
  }
}

// 正确示例 - 正确管理定时器
class GoodTimerHandler {
  constructor() {
    this.data = new Array(100000).fill('data');
    this.timers = new Set();
    this.isActive = true;
  }
  
  startProcessing() {
    const timer = setInterval(() => {
      if (this.isActive) {
        this.processData();
      }
    }, 1000);
    
    this.timers.add(timer);
    return timer;
  }
  
  processData() {
    console.log('处理数据:', this.data.length);
  }
  
  cleanup() {
    this.isActive = false;
    this.timers.forEach(timer => clearInterval(timer));
    this.timers.clear();
    this.data = null;
  }
}

// 定时器管理器
class TimerManager {
  constructor() {
    this.timers = new Map();
  }
  
  setTimeout(callback, delay, id = null) {
    const timerId = id || Math.random().toString(36);
    
    const timer = setTimeout(() => {
      callback();
      this.timers.delete(timerId);
    }, delay);
    
    this.timers.set(timerId, timer);
    return timerId;
  }
  
  setInterval(callback, interval, id = null) {
    const timerId = id || Math.random().toString(36);
    const timer = setInterval(callback, interval);
    this.timers.set(timerId, timer);
    return timerId;
  }
  
  clear(id) {
    const timer = this.timers.get(id);
    if (timer) {
      clearTimeout(timer);
      clearInterval(timer);
      this.timers.delete(id);
    }
  }
  
  clearAll() {
    this.timers.forEach((timer) => {
      clearTimeout(timer);
      clearInterval(timer);
    });
    this.timers.clear();
  }
}

4. 内存监控和诊断：

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

class MemoryProfiler {
  constructor() {
    this.profiles = [];
    this.isMonitoring = false;
  }
  
  startMonitoring(interval = 5000) {
    if (this.isMonitoring) return;
    
    this.isMonitoring = true;
    this.monitorTimer = setInterval(() => {
      this.collectMemoryProfile();
    }, interval);
  }
  
  stopMonitoring() {
    if (this.monitorTimer) {
      clearInterval(this.monitorTimer);
      this.isMonitoring = false;
    }
  }
  
  collectMemoryProfile() {
    const usage = process.memoryUsage();
    const profile = {
      timestamp: Date.now(),
      rss: usage.rss,
      heapUsed: usage.heapUsed,
      heapTotal: usage.heapTotal,
      external: usage.external
    };
    
    this.profiles.push(profile);
    
    // 保留最近1000个采样点
    if (this.profiles.length > 1000) {
      this.profiles.shift();
    }
    
    // 检测内存增长趋势
    this.detectMemoryLeaks();
  }
  
  detectMemoryLeaks() {
    if (this.profiles.length < 10) return;
    
    const recent = this.profiles.slice(-10);
    const growth = recent[recent.length - 1].heapUsed - recent[0].heapUsed;
    const timeSpan = recent[recent.length - 1].timestamp - recent[0].timestamp;
    
    // 如果10个采样点内堆内存增长超过10MB
    if (growth > 10 * 1024 * 1024) {
      console.warn('检测到可能的内存泄漏:');
      console.warn(`时间跨度: ${timeSpan}ms`);
      console.warn(`内存增长: ${Math.round(growth / 1024 / 1024)} MB`);
      
      this.generateMemoryReport();
    }
  }
  
  generateMemoryReport() {
    const report = {
      timestamp: new Date().toISOString(),
      profiles: this.profiles.slice(-50), // 最近50个采样点
      gcStats: v8.getHeapStatistics(),
      processInfo: {
        pid: process.pid,
        uptime: process.uptime(),
        version: process.version
      }
    };
    
    const reportPath = path.join(__dirname, 'memory-reports', `memory-${Date.now()}.json`);
    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
    console.log('内存报告已生成:', reportPath);
  }
  
  // 生成堆快照
  async takeHeapSnapshot(filename) {
    if (!global.gc) {
      console.warn('需要 --expose-gc 标志来生成堆快照');
      return;
    }
    
    // 先进行垃圾回收
    global.gc();
    
    const heapSnapshot = v8.getHeapSnapshot();
    const snapshotPath = path.join(__dirname, 'heap-snapshots', filename || `heap-${Date.now()}.heapsnapshot`);
    
    const writeStream = fs.createWriteStream(snapshotPath);
    heapSnapshot.pipe(writeStream);
    
    return new Promise((resolve, reject) => {
      writeStream.on('finish', () => {
        console.log('堆快照已保存:', snapshotPath);
        resolve(snapshotPath);
      });
      writeStream.on('error', reject);
    });
  }
}

const profiler = new MemoryProfiler();
profiler.startMonitoring();