Node.js环境搭建与核心模块实战指南

1. Node.js入门指南：从安装到实战

作为一名长期使用Node.js开发全栈应用的工程师，我经常被问到如何快速上手这个强大的JavaScript运行时环境。不同于浏览器中的JavaScript，Node.js让我们能够在服务器端运行JS代码，这彻底改变了前端开发的游戏规则。无论是构建高性能API、开发实时应用还是编写脚本工具，Node.js都展现出惊人的灵活性。

2. Node.js环境搭建全攻略

2.1 版本选择策略

在安装Node.js之前，版本选择是第一个需要慎重考虑的问题。目前Node.js主要有三个版本线：

• LTS（长期支持版）：如18.x、20.x，适合生产环境
• Current（当前版）：包含最新特性，适合尝鲜
• Nightly（每日构建版）：极不稳定，仅供测试

对于大多数开发者，我强烈建议选择最新的LTS版本。可以通过以下命令检查当前版本：

bash复制node -v
npm -v

注意：避免在生产环境使用奇数版本（如19.x），这些通常是过渡版本，支持周期短。

2.2 多平台安装详解

Windows系统安装

1. 访问Node.js官网下载LTS版本的.msi安装包
2. 运行安装向导时勾选"Automatically install the necessary tools"选项
3. 安装完成后，在PowerShell中验证：

powershell复制Get-Command node

常见问题：如果遇到权限错误，需要以管理员身份运行终端。

macOS安装最佳实践

推荐使用Homebrew进行安装：

bash复制brew install node

对于需要多版本管理的用户，nvm是更好的选择：

bash复制curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
nvm install --lts

Linux环境配置

对于Ubuntu/Debian系统：

bash复制curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

3. Node.js核心模块深度解析

3.1 文件系统操作

Node.js的fs模块提供了丰富的文件操作API。同步和异步两种风格需要根据场景选择：

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

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

// 同步读取
try {
  const data = fs.readFileSync('example.txt', 'utf8');
  console.log(data);
} catch (err) {
  console.error(err);
}

实际经验：生产环境中建议优先使用异步API，避免阻塞事件循环。

3.2 HTTP服务器构建

用Node.js创建基础HTTP服务器只需几行代码：

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

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World\n');
});

server.listen(3000, '127.0.0.1', () => {
  console.log('Server running at http://127.0.0.1:3000/');
});

性能优化技巧：

• 使用keep-alive减少连接开销
• 合理设置timeout避免资源浪费
• 考虑使用反向代理（如Nginx）处理静态文件

4. 现代Node.js开发实战

4.1 使用Express框架快速开发API

Express是Node.js最流行的Web框架：

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

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

app.listen(3000, () => {
  console.log('Example app listening on port 3000!');
});

项目结构建议：

code复制project/
├── node_modules/
├── src/
│   ├── controllers/
│   ├── models/
│   ├── routes/
│   └── app.js
├── .env
├── package.json
└── README.md

4.2 调试与性能优化

调试技巧

使用内置调试器：

bash复制node inspect app.js

Chrome DevTools调试：

bash复制node --inspect app.js

性能监控关键指标

• 事件循环延迟
• 内存使用情况
• HTTP请求吞吐量

推荐工具：

• Clinic.js
• Node.js Performance Hooks
• PM2监控

5. 常见问题解决方案

5.1 依赖管理问题

npm install失败常见原因：

1. 网络连接问题（可尝试切换镜像源）
2. 权限不足（避免使用root权限）
3. node_modules缓存损坏（清理缓存：npm cache clean --force）

5.2 版本冲突处理

使用nvm管理多版本：

bash复制nvm use 18
nvm alias default 18

5.3 内存泄漏排查

典型症状：

• 内存使用持续增长
• 应用响应变慢

诊断工具：

• heapdump生成内存快照
• Chrome DevTools Memory面板分析

6. 安全最佳实践

6.1 依赖安全扫描

定期检查项目漏洞：

bash复制npm audit

自动更新依赖：

bash复制npm outdated
npm update

6.2 环境变量管理

永远不要将敏感信息硬编码在代码中。使用dotenv管理环境变量：

javascript复制require('dotenv').config();
console.log(process.env.DB_PASSWORD);

.env文件示例：

code复制DB_HOST=localhost
DB_USER=root
DB_PASS=s1mpl3

7. 项目实战：构建RESTful API

完整示例：用户管理系统

javascript复制const express = require('express');
const bodyParser = require('body-parser');
const app = express();

app.use(bodyParser.json());

let users = [];

app.post('/users', (req, res) => {
  const user = req.body;
  users.push(user);
  res.status(201).send(user);
});

app.get('/users', (req, res) => {
  res.json(users);
});

app.listen(3000, () => console.log('Server started'));

测试方法：

bash复制curl -X POST -H "Content-Type: application/json" -d '{"name":"John"}' http://localhost:3000/users
curl http://localhost:3000/users

8. 部署与持续集成

8.1 PM2生产环境部署

安装PM2：

bash复制npm install pm2 -g

启动应用：

bash复制pm2 start app.js

常用命令：

• pm2 list 查看运行中进程
• pm2 logs 显示日志
• pm2 monit 监控资源使用

8.2 Docker化Node.js应用

Dockerfile示例：

dockerfile复制FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

构建和运行：

bash复制docker build -t node-app .
docker run -p 3000:3000 -d node-app

9. 生态工具链推荐

9.1 开发工具

• VS Code + Node.js扩展
• Postman API测试
• TablePlus数据库管理

9.2 测试框架

• Jest：全能测试框架
• Mocha + Chai：灵活组合
• Supertest：HTTP断言

9.3 模板引擎

• EJS：嵌入式JavaScript
• Pug：简洁的缩进语法
• Handlebars：逻辑与视图分离

10. 性能优化进阶

10.1 集群模式

利用多核CPU：

javascript复制const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  require('./app');
}

10.2 流处理优化

处理大文件时避免内存溢出：

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

fs.createReadStream('bigfile.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('bigfile.txt.gz'));

11. 调试技巧实录

11.1 断点调试

在VS Code中配置launch.json：

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

11.2 日志分级

使用winston日志库：

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

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

logger.info('Hello world');

12. 现代JavaScript特性应用

12.1 ES模块系统

package.json中设置：

json复制{
  "type": "module"
}

使用示例：

javascript复制import express from 'express';
const app = express();

12.2 异步编程演进

从回调到async/await：

javascript复制// 回调地狱
fs.readFile('file1', (err, data1) => {
  fs.readFile('file2', (err, data2) => {
    // ...
  });
});

// Promise链
fs.promises.readFile('file1')
  .then(data1 => fs.promises.readFile('file2'))
  .then(data2 => { /* ... */ });

// async/await
async function readFiles() {
  const data1 = await fs.promises.readFile('file1');
  const data2 = await fs.promises.readFile('file2');
  // ...
}

13. 微服务架构实践

13.1 使用NestJS构建微服务

安装NestJS CLI：

bash复制npm i -g @nestjs/cli
nest new project-name

创建微服务：

typescript复制import { MicroserviceOptions, Transport } from '@nestjs/microservices';

app.connectMicroservice<MicroserviceOptions>({
  transport: Transport.TCP,
  options: { port: 3001 }
});

13.2 服务通信模式

• REST API
• GraphQL
• gRPC
• WebSockets

14. 数据库集成方案

14.1 MongoDB连接

使用mongoose ODM：

javascript复制const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/test');

const Schema = mongoose.Schema;
const userSchema = new Schema({ name: String });
const User = mongoose.model('User', userSchema);

const user = new User({ name: 'John' });
user.save();

14.2 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
}, { sequelize, modelName: 'user' });

(async () => {
  await sequelize.sync();
  const user = await User.create({ username: 'Jane' });
})();

15. 实时应用开发

15.1 Socket.IO集成

安装Socket.IO：

bash复制npm install socket.io

服务端代码：

javascript复制const server = require('http').createServer();
const io = require('socket.io')(server);

io.on('connection', (socket) => {
  socket.emit('news', { hello: 'world' });
  socket.on('update', (data) => {
    console.log(data);
  });
});

server.listen(3000);

客户端代码：

html复制<script src="/socket.io/socket.io.js"></script>
<script>
  const socket = io('http://localhost');
  socket.on('news', (data) => {
    console.log(data);
    socket.emit('update', { my: 'data' });
  });
</script>

16. 测试驱动开发实践

16.1 单元测试示例

使用Jest测试一个简单函数：

javascript复制// sum.js
function sum(a, b) {
  return a + b;
}
module.exports = sum;

// sum.test.js
const sum = require('./sum');

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

16.2 集成测试策略

测试Express路由：

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

describe('GET /users', () => {
  it('responds with JSON', async () => {
    const response = await request(app)
      .get('/users')
      .expect('Content-Type', /json/)
      .expect(200);
    
    expect(response.body).toEqual([]);
  });
});

17. 错误处理最佳实践

17.1 中间件错误处理

Express错误处理中间件：

javascript复制app.get('/error', (req, res, next) => {
  try {
    throw new Error('Something broke!');
  } catch (err) {
    next(err);
  }
});

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something went wrong!');
});

17.2 未捕获异常处理

进程级别捕获：

javascript复制process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
});

18. 项目脚手架工具

18.1 自定义生成器

使用plop创建模板：

javascript复制// plopfile.js
module.exports = function(plop) {
  plop.setGenerator('controller', {
    description: 'Create a new controller',
    prompts: [{
      type: 'input',
      name: 'name',
      message: 'Controller name:'
    }],
    actions: [{
      type: 'add',
      path: 'src/controllers/{{name}}.js',
      templateFile: 'plop-templates/controller.hbs'
    }]
  });
};

18.2 流行脚手架工具

• create-react-app
• vue-cli
• express-generator

19. 性能监控与调优

19.1 基准测试

使用benchmark模块：

javascript复制const Benchmark = require('benchmark');
const suite = new Benchmark.Suite;

suite.add('RegExp#test', () => /o/.test('Hello World!'))
  .add('String#indexOf', () => 'Hello World!'.indexOf('o') > -1)
  .on('cycle', (event) => {
    console.log(String(event.target));
  })
  .run();

19.2 内存分析

生成堆快照：

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

setInterval(() => {
  heapdump.writeSnapshot((err, filename) => {
    console.log('Heap dump written to', filename);
  });
}, 60000);

20. 部署策略进阶

20.1 零停机部署

使用PM2的reload：

bash复制pm2 reload app

20.2 蓝绿部署

Docker Compose示例：

yaml复制version: '3'
services:
  app_blue:
    image: node-app:1.0
    ports:
      - "3000:3000"
  app_green:
    image: node-app:2.0
    ports:
      - "3001:3000"

通过Nginx切换流量：

nginx复制upstream backend {
  server app_blue:3000;
  server app_green:3000 backup;
}

21. Serverless架构应用

21.1 AWS Lambda部署

使用Serverless Framework：

bash复制npm install -g serverless
serverless create --template aws-nodejs

handler.js示例：

javascript复制module.exports.hello = async (event) => {
  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Hello World' })
  };
};

21.2 冷启动优化

• 减小包体积
• 预初始化连接
• 使用Provisioned Concurrency

22. 安全加固措施

22.1 Helmet中间件

增强Express安全：

javascript复制const helmet = require('helmet');
app.use(helmet());

22.2 输入验证

使用Joi验证器：

javascript复制const Joi = require('joi');

const schema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  password: Joi.string().pattern(new RegExp('^[a-zA-Z0-9]{3,30}$'))
});

const { error, value } = schema.validate({ username: 'abc', password: '123' });

23. 现代前端集成

23.1 SSR方案

使用Next.js：

bash复制npx create-next-app@latest

页面示例：

javascript复制export async function getServerSideProps() {
  const res = await fetch('https://api.example.com/data');
  const data = await res.json();
  return { props: { data } };
}

export default function Page({ data }) {
  return <div>{data}</div>;
}

23.2 同构应用

共享验证逻辑：

javascript复制// shared/validation.js
export function validateUser(user) {
  // 客户端和服务端都能使用的验证逻辑
}

24. 微前端架构

24.1 Module Federation

Webpack配置示例：

javascript复制// app1/webpack.config.js
new ModuleFederationPlugin({
  name: 'app1',
  filename: 'remoteEntry.js',
  exposes: {
    './Button': './src/Button'
  }
});

// app2/webpack.config.js
new ModuleFederationPlugin({
  name: 'app2',
  remotes: {
    app1: 'app1@http://localhost:3001/remoteEntry.js'
  }
});

24.2 样式隔离

使用Shadow DOM：

javascript复制class MyElement extends HTMLElement {
  constructor() {
    super();
    this.attachShadow({ mode: 'open' });
    this.shadowRoot.innerHTML = `
      <style>
        p { color: red; }
      </style>
      <p>Hello from shadow DOM</p>
    `;
  }
}
customElements.define('my-element', MyElement);

25. 性能优化终极指南

25.1 事件循环优化

监控事件循环延迟：

javascript复制const monitor = require('event-loop-lag');

const lag = monitor(1000); // 每秒检查一次
setInterval(() => {
  console.log(`${lag()}ms lag`);
}, 1000);

优化建议：

• 分解CPU密集型任务
• 使用worker线程
• 避免同步IO操作

25.2 缓存策略

内存缓存示例：

javascript复制const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 600 });

function getData(key) {
  let data = cache.get(key);
  if (!data) {
    data = fetchDataFromDB(key);
    cache.set(key, data);
  }
  return data;
}

26. 调试生产环境问题

26.1 核心转储分析

生成核心转储：

bash复制ulimit -c unlimited
node --abort-on-uncaught-exception app.js

分析工具：

• llnode
• mdb

26.2 性能剖析

CPU剖析：

bash复制node --prof app.js
node --prof-process isolate-0xnnnnnnnnnnnn-v8.log > processed.txt

火焰图生成：

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

27. 多线程编程

27.1 Worker Threads基础

创建worker：

javascript复制const { Worker } = require('worker_threads');

const worker = new Worker(`
  const { parentPort } = require('worker_threads');
  parentPort.on('message', (msg) => {
    parentPort.postMessage(msg * 2);
  });
`, { eval: true });

worker.on('message', (msg) => {
  console.log(msg); // 输入2得到4
});

worker.postMessage(2);

27.2 线程池实现

使用workerpool：

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

function heavyTask(input) {
  // CPU密集型任务
  return input * 2;
}

workerpool.worker({ heavyTask });

28. 国际化方案

28.1 i18n实现

使用i18n库：

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

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

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

28.2 多语言资源文件

locales/en.json:

json复制{
  "Hello": "Hello World"
}

locales/zh.json:

json复制{
  "Hello": "你好世界"
}

29. 认证与授权

29.1 JWT实现

使用jsonwebtoken：

javascript复制const jwt = require('jsonwebtoken');

const token = jwt.sign({ userId: 123 }, 'secret', { expiresIn: '1h' });
const decoded = jwt.verify(token, 'secret');

29.2 OAuth2集成

Passport策略示例：

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

passport.use(new GoogleStrategy({
    clientID: GOOGLE_CLIENT_ID,
    clientSecret: GOOGLE_CLIENT_SECRET,
    callbackURL: "/auth/google/callback"
  },
  (accessToken, refreshToken, profile, done) => {
    User.findOrCreate({ googleId: profile.id }, (err, user) => {
      return done(err, user);
    });
  }
));

30. GraphQL API开发

30.1 Apollo Server搭建

基础服务：

javascript复制const { ApolloServer, gql } = require('apollo-server');

const typeDefs = gql`
  type Query {
    hello: String
  }
`;

const resolvers = {
  Query: {
    hello: () => 'Hello world!'
  }
};

const server = new ApolloServer({ typeDefs, resolvers });
server.listen().then(({ url }) => {
  console.log(`Server ready at ${url}`);
});

30.2 数据加载优化

使用DataLoader解决N+1问题：

javascript复制const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
  const users = await User.find({ _id: { $in: userIds } });
  return userIds.map(id => users.find(u => u.id === id));
});

// 在resolver中使用
const user = await userLoader.load(userId);

31. WebAssembly集成

31.1 调用C++代码

编写C++模块：

cpp复制// add.cc
extern "C" {
  int add(int a, int b) {
    return a + b;
  }
}

编译为WASM：

bash复制emcc add.cc -Os -s WASM=1 -s SIDE_MODULE=1 -o add.wasm

Node.js调用：

javascript复制const fs = require('fs');
const wasmBuffer = fs.readFileSync('add.wasm');
WebAssembly.instantiate(wasmBuffer).then(wasmModule => {
  const { add } = wasmModule.instance.exports;
  console.log(add(2, 3)); // 5
});

31.2 性能对比

Fibonacci实现对比：

javascript复制// JavaScript实现
function fibJS(n) {
  if (n <= 1) return n;
  return fibJS(n - 1) + fibJS(n - 2);
}

// WASM实现
const { fibWASM } = wasmModule.instance.exports;

console.time('JS');
fibJS(40);
console.timeEnd('JS');

console.time('WASM');
fibWASM(40);
console.timeEnd('WASM');

32. 命令行工具开发

32.1 Commander.js应用

创建CLI工具：

javascript复制#!/usr/bin/env node
const { program } = require('commander');

program
  .version('1.0.0')
  .option('-d, --debug', 'output extra debugging')
  .option('-s, --small', 'small pizza size')
  .parse(process.argv);

if (program.debug) console.log(program.opts());

32.2 交互式命令行

使用Inquirer.js：

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

inquirer
  .prompt([
    {
      type: 'input',
      name: 'name',
      message: 'Your name:'
    }
  ])
  .then(answers => {
    console.log(`Hello ${answers.name}!`);
  });

33. 原生插件开发

33.1 N-API基础

创建原生模块：

cpp复制// hello.cc
#include <node_api.h>

napi_value Method(napi_env env, napi_callback_info args) {
  napi_value greeting;
  napi_create_string_utf8(env, "world", NAPI_AUTO_LENGTH, &greeting);
  return greeting;
}

napi_value init(napi_env env, napi_value exports) {
  napi_property_descriptor desc = { "hello", 0, Method, 0, 0, 0, napi_default, 0 };
  napi_define_properties(env, exports, 1, &desc);
  return exports;
}

NAPI_MODULE(NODE_GYP_MODULE_NAME, init)

33.2 构建配置

binding.gyp：

json复制{
  "targets": [
    {
      "target_name": "hello",
      "sources": [ "hello.cc" ],
      "include_dirs": ["<!@(node -p \"require('node-addon-api').include\")"],
      "dependencies": ["<!(node -p \"require('node-addon-api').gyp\")"]
    }
  ]
}

34. 子进程管理

34.1 exec与spawn对比

exec适合小量输出：

javascript复制const { exec } = require('child_process');
exec('ls -lh', (error, stdout, stderr) => {
  if (error) throw error;
  console.log(stdout);
});

spawn适合大量数据：

javascript复制const { spawn } = require('child_process');
const ls = spawn('ls', ['-lh']);

ls.stdout.on('data', (data) => {
  console.log(`stdout: ${data}`);
});

34.2 进程间通信

父进程：

javascript复制const { fork } = require('child_process');
const child = fork('child.js');

child.on('message', (msg) => {
  console.log('Parent received:', msg);
});

child.send({ hello: 'world' });

子进程(child.js)：

javascript复制process.on('message', (msg) => {
  console.log('Child received:', msg);
  process.send({ foo: 'bar' });
});

35. 代码质量保障

35.1 ESLint配置

.eslintrc.js示例：

javascript复制module.exports = {
  env: {
    node: true,
    es2021: true
  },
  extends: 'eslint:recommended',
  parserOptions: {
    ecmaVersion: 'latest'
  },
  rules: {
    'no-console': 'warn',
    'semi': ['error', 'always']
  }
};

35.2 代码格式化

Prettier配置：

json复制{
  "semi": true,
  "singleQuote": true,
  "printWidth": 80,
  "tabWidth": 2
}

36. 容器化进阶

36.1 多阶段构建

优化Docker镜像大小：

dockerfile复制FROM node:18 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm install --production
EXPOSE 3000
CMD ["node", "dist/app.js"]

36.2 Kubernetes部署

deployment.yaml示例：

yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: node-app
  template:
    metadata:
      labels:
        app: node-app
    spec:
      containers:
      - name: node-app
        image: node-app:1.0
        ports:
        - containerPort: 3000

37. 监控与告警

37.1 Prometheus监控

添加指标：

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

const httpRequestDurationMicroseconds = new prometheus.Histogram({
  name: 'http_request_duration_ms',
  help: 'Duration of HTTP requests in ms',
  labelNames: ['method', 'route', 'code'],
  buckets: [0.1, 5, 15, 50, 100, 200, 300, 400, 500]
});

app.use((req, res, next) => {
  const end = httpRequestDurationMicroseconds.startTimer();
  res.on('finish', () => {
    end({ method: req.method, route: req.path, code: res.statusCode });
  });
  next();
});

37.2 健康检查端点

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

38. 消息队列集成

38.1 RabbitMQ示例

发送消息：

javascript复制const amqp = require('amqplib');

async function send() {
  const conn = await amqp.connect('amqp://localhost');
  const channel = await conn.createChannel();
  const queue = 'hello';
  
  await channel.assertQueue(queue, { durable: false });
  channel.sendToQueue(queue, Buffer.from('Hello RabbitMQ!'));
}

send();

接收消息：

javascript复制const amqp = require('amqplib');

async function receive() {
  const conn = await amqp.connect('amqp://localhost');
  const channel = await conn.createChannel();
  const queue = 'hello';
  
  await channel.assertQueue(queue, { durable: false });
  channel.consume(queue, (msg) => {
    console.log(msg.content.toString());
  }, { noAck: true });
}

receive();

38.2 Kafka生产者

javascript复制const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'my-app',
  brokers: ['localhost:9092']
});

const producer = kafka.producer();

async function send() {
  await producer.connect();
  await producer.send({
    topic: 'test-topic',
    messages: [{ value: 'Hello Kafka!' }]
  });
  await producer.disconnect();
}

send();

39. 测试覆盖率

39.1 Istanbul/NYC配置

package.json配置：

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

39.2 覆盖率报告

生成HTML报告：

bash复制nyc report --reporter=html

40. 持续集成配置

40.1 GitHub Actions

Node.js CI示例：

yaml复制name: Node.js CI

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    - name: Use Node.js
      uses: actions/setup-node@v1
      with:
        node-version: '18.x'
    - run: npm install
    - run: npm test

40.2 自动化部署

部署到Heroku：

yaml复制- name: Deploy to Heroku
  if: github.ref == 'refs/heads/main'
  uses: akhileshns/heroku-deploy@v3.12.12
  with:
    heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
    heroku_app_name: "your-app-name"
    heroku_email: "your-email@example.com"

41. 文档生成

41.1 JSDoc示例

代码注释：

javascript复制/**
 * Calculates the sum of two numbers
 * @param {number} a - The first number
 * @param {number} b - The second number
 * @returns {number} The sum of a and b
 */
function sum(a, b) {
  return a + b;
}

生成文档：

bash复制npx jsdoc src -d docs

41.2 Swagger API文档

使用swagger-jsdoc：

javascript复制const swaggerJSDoc = require('swagger-jsdoc');

const options = {
  definition: {
    openapi: '3.0.0',
    info: {
      title: 'Hello World',
      version: '1.0.0',
    },
  },
  apis: ['./routes/*.js'],
};

const swaggerSpec = swaggerJSDoc(options);
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));

42. 前端构建集成

42.1 Webpack配置

基础webpack.config.js：

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

module.exports = {
  entry: './src/index.js',
  output: {
    filename: 'bundle.js',
    path: path.resolve(__dirname, 'dist')
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: 'babel-loader'
      }
    ]
  }
};

42.2 热模块替换

Webpack Dev Server配置：

javascript复制devServer: {
  contentBase: './dist',
  hot: true
}

43. 移动开发

43.1 React Native集成

使用Node.js后端：

javascript复制// API服务
app.get('/api/mobile', (req, res) => {
  res.json({ message: 'Hello from Node.js!' });
});

// React Native