Node.js开发环境与命令行操作全解析

1. Node.js 开发环境基础操作

1.1 命令行目录操作详解

在 Node.js 开发中，熟练掌握命令行操作是必备技能。Windows 的 CMD 命令行提供了基础的目录导航功能，理解这些符号的含义能极大提升工作效率。

. 和 .. 这两个特殊符号在文件系统中有着特定含义：

• 单个点号 . 表示当前工作目录
• 双点号 .. 表示当前目录的父目录

实际操作示例：

bash复制# 假设当前目录是 D:\Projects\NodeApp
cd .  # 保持当前目录不变，仍为 D:\Projects\NodeApp
cd .. # 切换到上级目录 D:\Projects

进阶技巧：

1. 连续使用 .. 可以快速向上跳转多级目录：

   bash复制cd ..\..  # 从 D:\A\B\C 跳转到 D:\A
   

2. 结合目录名使用：

   bash复制cd ..\OtherProject  # 从当前目录的兄弟目录切换
   

注意：在 Linux/macOS 系统中，这些符号同样适用，路径分隔符改为正斜杠 /

1.2 跨平台路径操作建议

Node.js 是跨平台运行时，为保持代码兼容性，建议：

1. 使用 path 模块处理路径：

   javascript复制const path = require('path');
   const fullPath = path.join(__dirname, '..', 'config', 'app.json');
   

2. 避免硬编码路径分隔符（Windows 用 \，Unix 用 /）
3. 使用 process.cwd() 获取当前工作目录，而非依赖平台特定命令

2. Node.js 全局对象深度解析

2.1 全局对象对比分析

不同 JavaScript 运行环境的顶级对象存在差异：

2.2 globalThis 的统一方案

ES2020 引入的 globalThis 提供了跨环境的全局对象访问方式：

javascript复制// 在任何环境中都能安全访问全局对象
const globalObj = globalThis;

// 设置全局变量（不推荐，但有时必要）
globalThis.APP_VERSION = '1.0.0';

最佳实践：

1. 优先使用模块化开发，减少全局变量污染
2. 必须使用全局变量时，通过 globalThis 明确标识
3. 在 Node.js 中，可使用 global 直接访问，但要注意代码可移植性

2.3 全局变量管理技巧

1. 检查全局变量是否存在：

   javascript复制if (typeof globalThis.MyLib === 'undefined') {
     // 安全初始化
   }
   

2. 避免命名冲突：

   javascript复制globalThis.__MY_APP_CONFIG = { ... };
   

3. 使用 Symbol 创建唯一全局标识：

   javascript复制const APP_KEY = Symbol.for('myapp.unique_key');
   globalThis[APP_KEY] = {...};
   

3. Node.js 项目 Git 工作流实战

3.1 项目初始化规范流程

完整的 Node.js 项目 Git 初始化应包含以下步骤：

1. 创建项目目录并初始化 Git：

   bash复制mkdir my-node-project
   cd my-node-project
   git init
   

2. 创建合理的 .gitignore 文件：

   gitignore复制# 依赖目录
   node_modules/
   
   # 环境变量
   .env
   .env.local
   
   # 日志文件
   *.log
   logs/
   
   # 编辑器配置
   .vscode/
   .idea/
   
   # 系统文件
   .DS_Store
   Thumbs.db
   

3. 首次提交：

   bash复制git add .
   git commit -m "chore: 初始化项目骨架"
   

3.2 分支管理策略

推荐采用 Git Flow 分支模型：

1. main 分支：生产环境代码，只接受合并请求
2. develop 分支：集成开发分支
3. feature/* 分支：功能开发分支
4. hotfix/* 分支：紧急修复分支

常用命令示例：

bash复制# 创建并切换分支
git checkout -b feature/user-auth

# 合并分支到 develop
git checkout develop
git merge feature/user-auth

# 删除已合并分支
git branch -d feature/user-auth

3.3 高级 Git 技巧

1. 交互式 rebase 整理提交历史：

   bash复制git rebase -i HEAD~3
   

2. 暂存修改（stash）：

   bash复制git stash push -m "WIP: 用户模块"
   git stash pop
   

3. 二分查找定位问题提交：

   bash复制git bisect start
   git bisect bad
   git bisect good v1.0.0
   

4. Node.js URL 处理全攻略

4.1 原生模块解析方案

Node.js 提供多种 URL 处理方式：

1. 传统 url + querystring 模块：

   javascript复制const url = require('url');
   const querystring = require('querystring');
   
   const demoUrl = 'https://example.com/search?q=nodejs&page=2';
   const parsed = url.parse(demoUrl);
   const params = querystring.parse(parsed.query);
   
   console.log(params.q); // 'nodejs'
   

2. 现代 WHATWG URL API：

   javascript复制const { URL } = require('url');
   
   const myUrl = new URL('https://example.com/books?id=123');
   console.log(myUrl.searchParams.get('id')); // '123'
   

性能对比：

• WHATWG API 更符合 Web 标准
• 传统 API 在简单场景下性能略优

4.2 Express 框架最佳实践

Express 提供了便捷的请求参数处理：

javascript复制const express = require('express');
const app = express();

// 查询参数
app.get('/search', (req, res) => {
  const { q, page = 1 } = req.query;
  // 处理搜索逻辑
});

// 路由参数
app.get('/users/:id', (req, res) => {
  const userId = req.params.id;
  // 获取用户信息
});

// POST 表单数据
app.post('/login', express.urlencoded(), (req, res) => {
  const { username, password } = req.body;
  // 验证逻辑
});

安全建议：

1. 始终验证输入参数
2. 使用 express-validator 进行数据校验
3. 对数字参数进行类型转换
4. 敏感操作使用 POST 而非 GET

4.3 高级 URL 处理技巧

1. 自定义查询参数解析：

   javascript复制function parseCustomQuery(str) {
     return str.split('&').reduce((acc, pair) => {
       const [key, value] = pair.split('=');
       acc[decodeURIComponent(key)] = decodeURIComponent(value || '');
       return acc;
     }, {});
   }
   

2. URL 构建器：

   javascript复制function buildUrl(base, params) {
     const url = new URL(base);
     Object.entries(params).forEach(([key, value]) => {
       url.searchParams.append(key, value);
     });
     return url.toString();
   }
   

3. 处理特殊字符：

   javascript复制const safeUrl = encodeURIComponent('https://example.com/?q=测试');
   

5. HTTP 状态码专业指南

5.1 状态码分类详解

HTTP 状态码分为五个类别，每个类别有特定的语义：

1xx (信息响应)

• 100 Continue：客户端应继续发送请求体
• 101 Switching Protocols：协议切换（如 WebSocket）

2xx (成功)

• 200 OK：标准成功响应
• 201 Created：资源创建成功
• 204 No Content：成功但无返回内容

3xx (重定向)

• 301 Moved Permanently：永久重定向
• 302 Found：临时重定向
• 304 Not Modified：缓存有效

4xx (客户端错误)

• 400 Bad Request：请求语法错误
• 401 Unauthorized：需要认证
• 403 Forbidden：无权限访问
• 404 Not Found：资源不存在

5xx (服务器错误)

• 500 Internal Server Error：通用服务器错误
• 502 Bad Gateway：上游服务器无效响应
• 503 Service Unavailable：服务不可用

5.2 Node.js 中的状态码设置

在原生 HTTP 模块中的使用：

javascript复制const http = require('http');

http.createServer((req, res) => {
  if (req.url === '/private') {
    res.writeHead(403, { 'Content-Type': 'text/plain' });
    return res.end('Forbidden');
  }
  
  res.statusCode = 200;
  res.end('OK');
}).listen(3000);

在 Express 框架中的使用：

javascript复制app.get('/api/users/:id', (req, res) => {
  User.find(req.params.id, (err, user) => {
    if (err) return res.status(500).json({ error: err.message });
    if (!user) return res.status(404).end();
    res.status(200).json(user);
  });
});

5.3 状态码使用最佳实践

1. RESTful API 设计原则：

   • GET：200 OK
   • POST：201 Created
   • PUT：200 OK 或 204 No Content
   • DELETE：204 No Content

2. 错误处理中间件示例：

   javascript复制app.use((err, req, res, next) => {
     console.error(err.stack);
     
     if (err instanceof ValidationError) {
       return res.status(400).json({ error: err.message });
     }
     
     res.status(500).send('Something broke!');
   });
   

3. 前端状态码处理策略：

   javascript复制fetch('/api/data')
     .then(response => {
       if (!response.ok) {
         throw new Error(`HTTP error! status: ${response.status}`);
       }
       return response.json();
     })
     .catch(error => {
       console.error('Fetch error:', error);
     });
   

6. 静态资源管理与优化

6.1 静态资源服务配置

原生 Node.js 实现静态文件服务：

javascript复制const http = require('http');
const fs = require('fs');
const path = require('path');

http.createServer((req, res) => {
  const filePath = path.join(__dirname, 'public', req.url);
  
  fs.stat(filePath, (err, stats) => {
    if (err || !stats.isFile()) {
      res.statusCode = 404;
      return res.end('Not Found');
    }
    
    const ext = path.extname(filePath).toLowerCase();
    const mimeTypes = {
      '.html': 'text/html',
      '.js': 'text/javascript',
      '.css': 'text/css',
      '.png': 'image/png'
    };
    
    res.setHeader('Content-Type', mimeTypes[ext] || 'application/octet-stream');
    fs.createReadStream(filePath).pipe(res);
  });
}).listen(3000);

6.2 Express 静态资源中间件

使用 express.static 的最佳实践：

javascript复制const express = require('express');
const app = express();

// 基本用法
app.use(express.static('public'));

// 带选项配置
app.use('/static', express.static('assets', {
  maxAge: '1y',
  setHeaders: (res, path) => {
    if (path.endsWith('.gz')) {
      res.set('Content-Encoding', 'gzip');
    }
  }
}));

6.3 高级优化策略

1. 资源压缩配置：

   javascript复制const compression = require('compression');
   app.use(compression({
     level: 6,
     threshold: 10 * 1024 // 大于10KB才压缩
   }));
   

2. 缓存控制策略：

   javascript复制app.use((req, res, next) => {
     if (req.url.startsWith('/static/')) {
       res.set('Cache-Control', 'public, max-age=31536000');
     }
     next();
   });
   

3. 非阻塞文件传输：

   javascript复制const send = require('send');
   
   app.get('/download/:file', (req, res) => {
     const file = path.join(__dirname, 'uploads', req.params.file);
     send(req, file).pipe(res);
   });
   

7. 路径处理进阶技巧

7.1 path 模块深度解析

path.extname 的精确行为：

javascript复制const path = require('path');

console.log(path.extname('index.html')); // '.html'
console.log(path.extname('README'));     // ''
console.log(path.extname('config.json')); // '.json'
console.log(path.extname('.env'));       // ''
console.log(path.extname('file.coffee.md')); // '.md'

7.2 文件路径操作实战

安全路径拼接：

javascript复制function getSafePath(userInput) {
  // 防止目录遍历攻击
  const safeInput = userInput.replace(/\.\./g, '');
  return path.join(__dirname, 'public', safeInput);
}

临时文件处理：

javascript复制const os = require('os');
const fs = require('fs');

const tempFile = path.join(os.tmpdir(), `upload_${Date.now()}`);
fs.writeFileSync(tempFile, '临时内容');

// 使用后清理
fs.unlinkSync(tempFile);

7.3 跨平台路径兼容方案

1. 统一路径风格：

   javascript复制function uniformPath(p) {
     return p.replace(/\\/g, '/');
   }
   

2. 路径规范化：

   javascript复制const cleanPath = path.normalize(userInputPath);
   

3. 相对路径解析：

   javascript复制const absolutePath = path.resolve('../config/app.json');
   

4. 路径组成部分解析：

   javascript复制const parsed = path.parse('/home/user/file.txt');
   /*
   {
     root: '/',
     dir: '/home/user',
     base: 'file.txt',
     ext: '.txt',
     name: 'file'
   }
   */
   

8. 模块系统与文件引入

8.1 模块导入导出模式

CommonJS 模块示例：

javascript复制// math.js
const add = (a, b) => a + b;
module.exports = { add };

// app.js
const { add } = require('./math');

ES 模块用法：

javascript复制// utils.mjs
export const double = x => x * 2;

// main.mjs
import { double } from './utils.mjs';

8.2 动态导入技巧

条件加载模块：

javascript复制async function loadModule(needsFeature) {
  if (needsFeature) {
    const feature = await import('./advanced-feature.js');
    feature.init();
  }
}

8.3 模块缓存机制

模块只会在第一次加载时执行：

javascript复制// counter.js
let count = 0;
module.exports = {
  increment: () => ++count,
  getCount: () => count
};

// a.js
const counter = require('./counter');
counter.increment(); // 1

// b.js
const counter = require('./counter');
console.log(counter.getCount()); // 1 (共享同一实例)

清除模块缓存（开发环境有用）：

javascript复制delete require.cache[require.resolve('./module')];

9. 实战项目结构设计

9.1 标准项目目录布局

推荐的项目结构：

code复制project-root/
├── src/
│   ├── controllers/   # 业务逻辑
│   ├── models/        # 数据模型
│   ├── routes/        # 路由定义
│   ├── services/      # 服务层
│   ├── utils/         # 工具函数
│   └── app.js         # 应用入口
├── config/            # 配置文件
├── public/            # 静态资源
├── tests/             # 测试代码
├── node_modules/      # 依赖
├── .env               # 环境变量
├── .gitignore         # Git忽略规则
└── package.json       # 项目配置

9.2 环境配置管理

多环境配置方案：

javascript复制// config/default.js
module.exports = {
  port: 3000,
  db: {
    host: 'localhost',
    name: 'app_dev'
  }
};

// config/production.js
module.exports = {
  port: process.env.PORT || 80,
  db: {
    host: process.env.DB_HOST,
    name: process.env.DB_NAME
  }
};

// 使用方式
const config = require('./config/' + (process.env.NODE_ENV || 'default'));

9.3 应用启动优化

集群模式启动：

javascript复制const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const cpuCount = os.cpus().length;
  for (let i = 0; i < cpuCount; i++) {
    cluster.fork();
  }
} else {
  require('./app');
}

10. 调试与性能优化

10.1 Node.js 调试技巧

使用内置调试器：

bash复制node inspect app.js

Chrome DevTools 调试：

bash复制node --inspect-brk app.js

VSCode 调试配置：

json复制{
  "type": "node",
  "request": "launch",
  "name": "Launch Program",
  "skipFiles": ["<node_internals>/**"],
  "program": "${workspaceFolder}/app.js"
}

10.2 性能分析工具

CPU 分析：

bash复制node --cpu-prof app.js

内存分析：

bash复制node --heap-prof app.js

火焰图生成：

bash复制npm install -g flamebearer
node --prof app.js
node --prof-process --preprocess -j isolate*.log | flamebearer

10.3 常见性能优化

1. 避免同步操作：

   javascript复制// 错误示范
   const data = fs.readFileSync('large.txt');
   
   // 正确做法
   fs.readFile('large.txt', (err, data) => {
     // 处理数据
   });
   

2. 流式处理大文件：

   javascript复制const readStream = fs.createReadStream('input.txt');
   const writeStream = fs.createWriteStream('output.txt');
   readStream.pipe(writeStream);
   

3. 连接池管理：

   javascript复制const pool = mysql.createPool({
     connectionLimit: 10,
     host: 'localhost',
     user: 'root',
     password: '',
     database: 'test'
   });
   

4. 合理使用缓存：

   javascript复制const cache = new Map();
   
   function getData(key) {
     if (cache.has(key)) {
       return Promise.resolve(cache.get(key));
     }
     
     return fetchData(key).then(data => {
       cache.set(key, data);
       return data;
     });
   }
   

11. 安全最佳实践

11.1 常见漏洞防护

1. SQL 注入防护：

   javascript复制// 错误示范
   db.query(`SELECT * FROM users WHERE id = ${userInput}`);
   
   // 正确做法
   db.query('SELECT * FROM users WHERE id = ?', [userInput]);
   

2. XSS 防护：

   javascript复制const escapeHtml = str => str.replace(/[&<>'"]/g, 
     tag => ({
       '&': '&amp;',
       '<': '&lt;',
       '>': '&gt;',
       "'": '&#39;',
       '"': '&quot;'
     }[tag]));
   

3. CSRF 防护：

   javascript复制const csrf = require('csurf');
   app.use(csrf());
   
   app.get('/form', (req, res) => {
     res.render('send', { csrfToken: req.csrfToken() });
   });
   

11.2 敏感数据管理

环境变量使用规范：

javascript复制require('dotenv').config();

const config = {
  dbPassword: process.env.DB_PASSWORD,
  apiKey: process.env.API_KEY
};

加密存储方案：

javascript复制const crypto = require('crypto');

function encrypt(text, key) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  let encrypted = cipher.update(text);
  encrypted = Buffer.concat([encrypted, cipher.final()]);
  return iv.toString('hex') + ':' + encrypted.toString('hex');
}

11.3 依赖安全审计

定期检查依赖漏洞：

bash复制npm audit

使用安全版本：

bash复制npm outdated
npm update --save

锁定依赖版本：

bash复制npm shrinkwrap

12. 测试与质量保障

12.1 单元测试实践

Jest 测试示例：

javascript复制const sum = require('./sum');

test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});

describe('math operations', () => {
  it('should multiply correctly', () => {
    expect(multiply(2, 3)).toBe(6);
  });
});

12.2 集成测试方案

Supertest 测试 API：

javascript复制const request = require('supertest');
const app = require('../app');

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

12.3 测试覆盖率

Istanbul/NYC 配置：

json复制{
  "scripts": {
    "test": "nyc mocha",
    "coverage": "nyc report --reporter=text-lcov > coverage.lcov"
  },
  "nyc": {
    "check-coverage": true,
    "lines": 80,
    "statements": 80,
    "functions": 80,
    "branches": 80
  }
}

13. 部署与运维

13.1 PM2 进程管理

基础用法：

bash复制pm2 start app.js -i max --name "api-server"

常用命令：

bash复制pm2 list          # 查看进程列表
pm2 logs          # 查看日志
pm2 reload all    # 零停机重启
pm2 save          # 保存当前配置
pm2 startup       # 设置开机启动

13.2 日志管理策略

日志分级配置：

javascript复制const winston = require('winston');

const logger = winston.createLogger({
  levels: winston.config.syslog.levels,
  transports: [
    new winston.transports.File({ 
      filename: 'error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'combined.log' 
    })
  ]
});

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

13.3 健康检查与监控

基础健康检查端点：

javascript复制app.get('/health', (req, res) => {
  res.json({
    status: 'UP',
    timestamp: Date.now(),
    uptime: process.uptime()
  });
});

Prometheus 监控集成：

javascript复制const client = require('prom-client');
const collectDefaultMetrics = client.collectDefaultMetrics;

collectDefaultMetrics({ timeout: 5000 });

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

14. 现代 JavaScript 特性应用

14.1 ES6+ 特性实践

解构赋值高级用法：

javascript复制// 函数参数解构
function connect({ host = 'localhost', port = 3000, user }) {
  console.log(`Connecting to ${user}@${host}:${port}`);
}

// 嵌套解构
const { 
  user: { 
    name, 
    preferences: { theme } 
  } 
} = config;

14.2 异步编程演进

从回调到 async/await：

javascript复制// 回调地狱
fs.readFile('a.txt', (err, a) => {
  fs.readFile('b.txt', (err, b) => {
    fs.writeFile('c.txt', a + b, (err) => {
      // ...
    });
  });
});

// Promise 链
readFile('a.txt')
  .then(a => readFile('b.txt').then(b => a + b))
  .then(data => writeFile('c.txt', data));

// async/await
async function processFiles() {
  const a = await readFile('a.txt');
  const b = await readFile('b.txt');
  await writeFile('c.txt', a + b);
}

14.3 TypeScript 集成

基础类型定义：

typescript复制interface User {
  id: number;
  name: string;
  email?: string;
}

function createUser(user: User): User {
  // ...
}

Node.js 类型支持：

bash复制npm install --save-dev @types/node

15. 生态工具链推荐

15.1 开发工具精选

1. 调试工具：

   • ndb：增强型调试器
   • node-inspect：CLI 调试器

2. 代码质量：

   • ESLint：代码规范检查
   • Prettier：代码格式化

3. 开发辅助：

   • nodemon：文件变更自动重启
   • concurrently：并行运行命令

15.2 性能工具集

1. 基准测试：

   • benchmark.js
   • autocannon

2. 内存分析：

   • heapdump
   • clinic.js

3. 监控工具：

   • PM2
   • AppDynamics

15.3 框架选型指南

16. 微服务与架构设计

16.1 微服务通信模式

REST API 设计：

javascript复制// users-service.js
const express = require('express');
const app = express();

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

app.listen(3001);

gRPC 实现：

javascript复制// proto/user.proto
service UserService {
  rpc GetUser (UserRequest) returns (User) {}
}

// server.js
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

const packageDefinition = protoLoader.loadSync('user.proto');
const userProto = grpc.loadPackageDefinition(packageDefinition);

const server = new grpc.Server();
server.addService(userProto.UserService.service, {
  getUser: (call, callback) => {
    callback(null, { id: call.request.id, name: 'John' });
  }
});

server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), () => {
  server.start();
});

16.2 服务发现与负载均衡

Consul 集成示例：

javascript复制const consul = require('consul')();

// 服务注册
consul.agent.service.register({
  name: 'user-service',
  address: 'localhost',
  port: 3001,
  check: {
    http: 'http://localhost:3001/health',
    interval: '10s'
  }
}, err => {
  if (err) throw err;
});

// 服务发现
consul.agent.services((err, services) => {
  console.log('Available services:', services);
});

16.3 断路器模式实现

使用 opossum：

javascript复制const CircuitBreaker = require('opossum');

function asyncFunctionThatCouldFail() {
  return new Promise((resolve, reject) => {
    if (Math.random() > 0.7) {
      reject('Service failed');
    } else {
      resolve('Success');
    }
  });
}

const breaker = new CircuitBreaker(asyncFunctionThatCouldFail, {
  timeout: 3000,
  errorThresholdPercentage: 50,
  resetTimeout: 30000
});

breaker.fallback(() => 'Sorry, service unavailable');
breaker.on('open', () => console.log('Circuit breaker opened'));
breaker.on('close', () => console.log('Circuit breaker closed'));

// 使用断路器
breaker.fire().then(console.log).catch(console.error);

17. 数据库集成方案

17.1 SQL 数据库操作

Sequelize ORM 示例：

javascript复制const { Sequelize, Model, DataTypes } = require('sequelize');
const sequelize = new Sequelize('sqlite::memory:');

class User extends Model {}
User.init({
  username: DataTypes.STRING,
  age: DataTypes.INTEGER
}, { sequelize, modelName: 'user' });

(async () => {
  await sequelize.sync();
  const user = await User.create({ username: 'John', age: 30 });
  console.log(user.toJSON());
})();

17.2 NoSQL 集成实践

MongoDB 使用示例：

javascript复制const { MongoClient } = require('mongodb');
const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);

async function run() {
  try {
    await client.connect();
    const db = client.db('test');
    const collection = db.collection('users');
    
    await collection.insertOne({ name: 'John', age: 30 });
    const users = await collection.find({ age: { $gt: 25 } }).toArray();
    console.log(users);
  } finally {
    await client.close();
  }
}

run().catch(console.dir);

17.3 数据库连接池优化

通用连接池配置：

javascript复制const { Pool } = require('pg');
const pool = new Pool({
  host: 'localhost',
  database: 'test',
  user: 'postgres',
  password: 'secret',
  max: 20, // 最大连接数
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000
});

async function query(text, params) {
  const start = Date.now();
  const res = await pool.query(text, params);
  const duration = Date.now() - start;
  console.log('Executed query', { text, duration, rows: res.rowCount });
  return res;
}

18. 实时通信技术

18.1 WebSocket 实现

原生 WebSocket 服务：

javascript复制const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
  ws.on('message', message => {
    console.log('Received:', message);
    ws.send(`Echo: ${message}`);
  });

  ws.send('Welcome to WebSocket server');
});

18.2 Socket.IO 进阶

房间和命名空间：

javascript复制const io = require('socket.io')(3000);

const chat = io.of('/chat').on('connection', socket => {
  socket.on('join', room => {
    socket.join(room);
    socket.to(room).emit('user joined', socket.id);
  });
  
  socket.on('message', (room, msg) => {
    socket.to(room).emit('message', msg);
  });
});

const admin = io.of('/admin').on('connection', socket => {
  socket.on('admin-msg', data => {
    admin.emit('admin-notify', data);
  });
});

18.3 实时性能优化

1. 二进制数据传输：

   javascript复制socket.on('binary', data => {
     const buffer = Buffer.from(data);
     // 处理二进制数据
   });
   

2. 心跳检测：

   javascript复制setInterval(() => {
     socket.ping(Date.now());
   }, 25000);
   
   socket.on('pong', latency => {
     console.log(`Latency: ${latency}ms`);
   });
   

3. 消息压缩：

   javascript复制const io = require('socket.io')({
     perMessageDeflate: {
       threshold: 1024 // 大于1KB的消息才压缩
     }
   });
   

19. 国际化与本地化

19.1 i18n 实现方案

使用 i18n 模块：

javascript复制const i18n = require('i18n');

i18n.configure({
  locales: ['en', 'zh'],
  directory: __dirname + '/locales',
  defaultLocale: 'en'
});

app.use(i18n.init);

app.get('/greet', (req, res) => {
  res.send(res.__('Hello'));
});

19.2 多语言资源管理

语言文件结构：

code复制locales/
├── en.json
└── zh.json

en.json 内容：

json复制{
  "Hello": "Hello",
  "Welcome": "Welcome, %s"
}

动态参数：

javascript复制res.__('Welcome', username);

19.3 区域敏感格式化

日期格式化：

javascript复制const date = new Date();
const formatter = new Intl.DateTimeFormat('zh-CN', {
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});

console.log(formatter.format(date)); // "2023年5月15日"

货币格式化：

javascript复制const formatter = new Intl.NumberFormat('zh-CN', {
  style: 'currency',
  currency: 'CNY'
});

console.log(formatter.format(1234.56)); // "¥1,234.56"

20. 前沿技术与趋势

20.1 Serverless 实践

AWS Lambda 示例：

javascript复制exports.handler = async (event) => {
  const name = event.queryStringParameters?.name || 'World';
  
  return {
    statusCode: 200,
    body: JSON.stringify({ 
      message: `Hello ${name}` 
    }),
  };
};

20.2 WebAssembly 集成

使用 WASM 模块：

javascript复制const fs = require('fs');
const { WASI } = require('wasi');
const wasm = fs.readFileSync('module.wasm');

const wasi = new WASI();
const instance = new WebAssembly.Instance(