# zh_js

**Repository Path**: nm97/zh_js

## Basic Information

- **Project Name**: zh_js
- **Description**: 禁止用于任何违法用途，使用者需自行承担全部责任
- **Primary Language**: Unknown
- **License**: MPL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 6
- **Created**: 2025-11-08
- **Last Updated**: 2025-11-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README


# 中文JavaScript库（zh_js）

## 项目地址

**Gitee公共仓库**：[https://gitee.com/xbkjlm/zh_js](https://gitee.com/xbkjlm/zh_js)

## 许可说明

本项目采用 **Mozilla Public License Version 2.0** 开源许可协议。

### MPL 2.0 许可证主要特点：
- **自由使用与修改**：您可以自由使用、修改本项目的源代码
- **衍生作品要求**：对本项目代码的修改必须在相同许可证下发布
- **商业友好**：允许将本项目集成到商业产品中
- **独立文件**：可以将MPL许可的文件与其他许可的文件组合成更大的作品

详细许可条款请参阅项目根目录下的 [LICENSE](LICENSE) 文件或访问官方网站：[http://mozilla.org/MPL/2.0/](http://mozilla.org/MPL/2.0/)

> **重要提示**：本源码不得用于违法或犯罪行为。使用者应独自承担使用本源码所产生的所有法律责任。作者不负责任何违法使用。

## 法律声明 

本项目仅供学习与研究使用，不得用于任何违反中华人民共和国法律法规的活动。  
使用本项目源码造成的任何直接或间接后果，由使用者本人承担全部责任。  
作者不对任何因不当使用而产生的法律问题负责。

## 项目结构说明

### test 目录 - 使用示例

`test` 目录包含了各个中文封装模块的使用示例代码，帮助开发者快速了解如何使用这些模块。

### zh 目录 - 中文封装模块

`zh` 目录包含了所有的中文封装模块代码，提供各种功能的中文API接口。

### 目录结构

```
test/
├── 公共函数/      # 公共函数使用示例
├── 前端/         # 前端相关功能使用示例
└── 后端/         # 后端相关功能使用示例

zh/
├── 公共函数/      # 公共函数中文封装
├── 前端/         # 前端相关功能中文封装
└── 后端/         # 后端相关功能中文封装
```

### 中文库详细目录结构

```
zh/
├── 公共函数/      # 公共函数中文封装
│   ├── zh-array.js      # 数组操作中文封装
│   ├── zh-date.js       # 日期操作中文封装
│   ├── zh-function.js   # 函数操作中文封装
│   ├── zh-heap.js       # 堆结构中文封装
│   ├── zh-map.js        # Map操作中文封装
│   ├── zh-math.js       # 数学操作中文封装
│   ├── zh-object.js     # 对象操作中文封装
│   ├── zh-promise.js    # Promise操作中文封装
│   ├── zh-queue.js      # 队列操作中文封装
│   ├── zh-set.js        # Set操作中文封装
│   ├── zh-stack.js      # 栈操作中文封装
│   ├── zh-string.js     # 字符串操作中文封装
│   └── zh-timer.js      # 定时器操作中文封装
├── 前端/         # 前端相关功能中文封装
│   ├── zh-dom.js        # DOM操作中文封装
│   ├── zh-storage.js    # 存储操作中文封装
│   ├── zh-url.js        # URL操作中文封装
│   └── zh-websocket.js  # WebSocket操作中文封装
└── 后端/         # 后端相关功能中文封装
    ├── CSV/            # CSV文件处理模块
    │   └── index.js
    ├── Express/        # Express框架中文封装
    │   └── index.js
    ├── PDF/            # PDF生成与处理模块
    │   └── index.js
    ├── Redis/          # Redis缓存操作模块
    │   └── index.js
    ├── Word/           # Word文档处理模块
    │   └── index.js
    ├── xlsx/           # Excel文件处理模块
    │   └── index.js
    ├── 令牌/           # JWT令牌处理模块
    │   └── index.js
    ├── 压缩_解压/       # 文件压缩与解压模块
    │   └── index.js
    ├── 参数检验/        # 请求参数验证模块
    │   └── index.js
    ├── 数据库操作/      # 数据库操作模块
    │   └── index.js
    ├── 文件上传/        # 文件上传处理模块
    │   └── index.js
    ├── 日志_输出/       # 日志记录模块
    │   └── index.js
    ├── 核心/           # 核心功能模块
    │   ├── HTTP.js        # HTTP操作中文封装
    │   ├── index.js       # 核心模块入口
    │   ├── 事件.js        # 事件处理中文封装
    │   ├── 加密.js        # 加密解密中文封装
    │   ├── 实用工具.js    # 实用工具中文封装
    │   ├── 文件系统.js    # 文件系统中文封装
    │   ├── 流.js          # 流操作中文封装
    │   ├── 路径.js        # 路径操作中文封装
    │   └── 进程与系统.js  # 进程与系统操作中文封装
    └── 邮件/           # 邮件发送模块
        └── index.js
```

### 中文库依赖安装指南

下表列出了各个模块所需的依赖包及其安装命令。根据项目需要，您可以选择性地安装相应模块的依赖：

### 公共函数模块
| 模块名称 | 所需依赖包 | npm 安装命令 |
|---------|------------|------------|
| 公共函数 | - (JavaScript 内置) | 无需额外安装 |

### 前端模块
| 模块名称 | 所需依赖包 | npm 安装命令 |
|---------|------------|------------|
| 前端功能 | - (浏览器内置) | 无需额外安装 |

### 后端模块
| 模块名称 | 所需依赖包 | npm 安装命令 |
|---------|------------|------------|
| Express | express, cookie-parser, express-session | `npm install express cookie-parser express-session` |
| 数据库操作 | sequelize, mysql2 | `npm install sequelize mysql2` |
| CSV | - (Node.js 内置) | 无需额外安装 |
| PDF | pdfmake, pdf-parse(可选), hummus(可选) | `npm install pdfmake pdf-parse hummus` |
| Redis | redis | `npm install redis` |
| Word | docx | `npm install docx` |
| xlsx | xlsx | `npm install xlsx` |
| 令牌 | jsonwebtoken | `npm install jsonwebtoken` |
| 压缩_解压 | archiver, unzipper, tar | `npm install archiver unzipper tar` |
| 参数检验 | joi | `npm install joi` |
| 文件上传 | multer | `npm install multer` |
| 日志_输出 | winston, morgan | `npm install winston morgan` |
| 邮件 | nodemailer | `npm install nodemailer` |
| 核心 | - (Node.js 内置) | 无需额外安装 |

**一键安装所有后端依赖的命令：**

```bash
npm install express cookie-parser express-session sequelize mysql2 pdfmake pdf-parse hummus redis docx xlsx jsonwebtoken archiver unzipper tar joi multer winston morgan nodemailer
```

> 提示：公共函数和前端模块主要基于 JavaScript 内置功能和浏览器 API，无需安装额外依赖。如果只使用部分后端模块，可以只安装相应模块的依赖，这样可以减小项目体积并加快安装速度。

## 中文库封装的命令

下表列出了各模块的中文封装函数详细信息：

### 公共函数模块
 

> **兼容性提示**  
> 公共模块同时支持 Node.js 与浏览器环境。  
> 默认使用 CommonJS 规范导出；如需 ES Module，请手动切换源码注释即可。

| 导出规范 | 源码示例 | 使用场景 |
| --- | --- | --- |
| **CommonJS**（默认） | `module.exports = { 数组 };`<br>`module.exports.数组 = 数组;` | Node.js 原生 require |
| **ES Module**（可选） | `export { 数组 };`<br>`export default 数组;` | 前端 import<br>Node.js 需开启 `"type": "module"` |

一键切换步骤：  
1. 打开对应模块文件  
2. 注释掉 CommonJS 段落  
3. 取消 ES Module 段落注释  

> 前端项目直接 `import` 即可；Node.js 若用 `import`，请先配置 `"type": "module"` 或使用 `.mjs` 后缀。

#### 数组操作中文封装

**模块信息**
- 模块文件名: zh-array.js
- 路径: zh/公共函数/zh-array.js
- 功能: 提供JavaScript数组的中文API封装，支持ES6+所有原生数组方法和链式调用

**核心特性**
- 所有操作均返回新数组实例，不修改原数组
- 完整支持链式调用
- 提供JSDoc参数提示
- 包含常用扩展工具方法

**命令总数：44个**

**基础操作函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 值 = [] | any[]\|any | 创建数组实例 | 数组实例 |
| 取值 | 无 | 无 | 获取当前数组的副本 | any[] |
| 打印 | 无 | 无 | 打印当前数组到控制台 | 数组实例（支持链式调用） |
| 长度 | 无 | 无 | 获取数组长度 | number |
| 取 | 索引 | number | 获取指定索引的元素 | any |

**元素增删改函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 添加 | ...元素 | any... | 添加元素到数组末尾 | 数组实例 |
| 插入 | 索引, ...元素 | number, any... | 在指定位置插入元素 | 数组实例 |
| 删除 | 索引, 数量 = 1 | number, number | 删除指定索引位置的元素 | 数组实例 |
| 清空 | 无 | 无 | 清空数组 | 数组实例（空数组） |
| 填充 | 值, 开始 = 0, 结束 = length | any, number, number | 填充数组元素 | 数组实例 |
| 拷贝到 | 目标索引, 开始 = 0, 结束 = length | number, number, number | 拷贝数组元素到目标位置 | 数组实例 |

**查找函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 查找 | 回调 | function | 查找第一个满足条件的元素 | any\|null |
| 查找最后 | 回调 | function | 查找最后一个满足条件的元素 | any\|null |
| 查找索引 | 回调 | function | 查找第一个满足条件的元素的索引 | number |
| 查找最后索引 | 回调 | function | 查找最后一个满足条件的元素的索引 | number |
| 索引 | 值 | any | 获取指定值的第一个索引 | number |
| 最后索引 | 值 | any | 获取指定值的最后一个索引 | number |
| 包含 | 值 | any | 判断数组是否包含指定值 | boolean |
| 包含值 | 值, 起始 = 0 | any, number | 判断数组是否包含指定值（可指定起始位置） | boolean |

**迭代与转换函数** (9个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 遍历 | 回调 | function | 遍历数组的每个元素 | 数组实例（支持链式调用） |
| 映射 | 回调 | function | 映射数组元素生成新数组 | 数组实例 |
| 过滤 | 回调 | function | 过滤数组元素 | 数组实例 |
| 规约 | 回调, 初始值 | function, any | 规约数组元素 | any |
| 全部 | 回调 | function | 判断是否所有元素都满足条件 | boolean |
| 某些 | 回调 | function | 判断是否有任意元素满足条件 | boolean |
| 键迭代 | 无 | 无 | 获取数组索引的迭代器 | Iterator<number> |
| 值迭代 | 无 | 无 | 获取数组值的迭代器 | Iterator<any> |
| 条目迭代 | 无 | 无 | 获取数组条目的迭代器 | Iterator<[number, any]> |

**数组操作函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 排序 | 比较函数 | function | 排序数组 | 数组实例 |
| 翻转 | 无 | 无 | 翻转数组顺序 | 数组实例 |
| 拼接 | ...数组项 | any... | 拼接多个数组或元素 | 数组实例 |
| 切片 | 开始 = 0, 结束 | number, number | 截取数组片段 | 数组实例 |
| 拍平 | 深度 = 1 | number | 拍平嵌套数组 | 数组实例 |
| 拍平映射 | 回调 | function | 映射并拍平数组 | 数组实例 |
| 合并 | ...数组项 | any... | 合并多个数组或元素（同拼接） | 数组实例 |
| 按分隔符拼接 | 分隔符 = "," | string | 按分隔符拼接数组元素为字符串 | string |

**扩展工具函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 去重 | 无 | 无 | 数组去重 | 数组实例 |
| 打乱 | 无 | 无 | 打乱数组顺序 | 数组实例 |
| 转字符串 | 无 | 无 | 转换为字符串 | string |
| 转本地字符串 | 无 | 无 | 转换为本地字符串 | string |

**静态方法** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否数组 | v | any | 判断是否为数组 | boolean |
| 从 | 可迭代, 映射函数 | ArrayLike\|Iterable, function | 从类数组或可迭代对象创建数组 | 数组实例 |
| 创建 | 长度, 填充值 = undefined | number, any | 创建指定长度的数组 | 数组实例 |
| 合并 | ...数组项 | any... | 合并多个数组或元素（静态方法） | 数组实例 |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 数组 } = require('./zh/公共函数/zh-array.js');
// 方法2: 直接导入数组构造函数
const 数组 = require('./zh/公共函数/zh-array.js').数组;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 数组 } from './zh/公共函数/zh-array.js';
// 方法2: 使用默认导入
import 数组 from './zh/公共函数/zh-array.js';
```

**基本使用示例:**
```javascript
// 创建数组并链式调用（使用 new 关键字）
const result = new 数组([1, 2, 3])
  .添加(4, 5)
  .映射(x => x * 2)
  .过滤(x => x > 5)
  .取值();
console.log(result); // [6, 8, 10]

// 使用静态方法（静态方法不需要 new 关键字）
const isArray = 数组.是否数组([1, 2, 3]); // true
const merged = 数组.合并([1, 2], [3, 4], 5); // [1, 2, 3, 4, 5]
```

#### 日期操作中文封装

**模块信息**
- 模块文件名: zh-date.js
- 路径: zh/公共函数/zh-date.js
- 功能: 提供JavaScript日期时间的中文API封装，支持日期时间操作、链式调用、格式化、运算和比较

**核心特性**
- 所有修改操作均返回新日期实例，不修改原日期
- 完整支持链式调用
- 提供JSDoc参数提示
- 支持日期格式化、运算和比较

**命令总数：26个**

**构造与取值函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 值 = new Date() | Date\|string\|number | 创建日期实例 | 日期实例 |
| 取值 | 无 | 无 | 获取原始Date对象的副本 | Date |
| 取时间戳 | 无 | 无 | 获取时间戳（毫秒） | number |
| ISO字符串 | 无 | 无 | 获取ISO格式的字符串 | string |
| 本地字符串 | 本地 = undefined, 选项 = {} | string\|string[], Object | 获取本地格式的字符串 | string |
| 格式化 | 模板 = 'YYYY-MM-DD HH:mm:ss' | string | 格式化日期为字符串 | string |

**日期时间获取函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取年份 | 无 | 无 | 获取年份值（四位数） | number |
| 取月份 | 无 | 无 | 获取月份值 (0-11，0表示1月) | number |
| 取日期 | 无 | 无 | 获取日期值 (1-31) | number |
| 取小时 | 无 | 无 | 获取小时值 (0-23) | number |
| 取分钟 | 无 | 无 | 获取分钟值 (0-59) | number |
| 取秒 | 无 | 无 | 获取秒值 (0-59) | number |
| 取毫秒 | 无 | 无 | 获取毫秒值 (0-999) | number |
| 周几 | 无 | 无 | 获取星期值 (0-6，0表示星期日) | number |

**日期时间设置函数** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设年份 | 年 | number | 设置年份，返回新日期（不修改原日期） | 日期实例 |
| 设月份 | 月 | number | 设置月份，返回新日期（不修改原日期） | 日期实例 |
| 设日期 | 日 | number | 设置日期，返回新日期（不修改原日期） | 日期实例 |
| 设小时 | 小时 | number | 设置小时，返回新日期（不修改原日期） | 日期实例 |
| 设分钟 | 分 | number | 设置分钟，返回新日期（不修改原日期） | 日期实例 |
| 设秒 | 秒 | number | 设置秒，返回新日期（不修改原日期） | 日期实例 |
| 设毫秒 | ms | number | 设置毫秒，返回新日期（不修改原日期） | 日期实例 |

**日期运算函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 加天数 | 天 | number | 日期加天数，返回新日期（不修改原日期） | 日期实例 |
| 减天数 | 天 | number | 日期减天数，返回新日期（不修改原日期） | 日期实例 |
| 加月 | 月数 | number | 日期加月数，返回新日期（不修改原日期） | 日期实例 |
| 减月 | 月数 | number | 日期减月数，返回新日期（不修改原日期） | 日期实例 |
| 加年 | 年数 | number | 日期加年数，返回新日期（不修改原日期） | 日期实例 |
| 减年 | 年数 | number | 日期减年数，返回新日期（不修改原日期） | 日期实例 |

**日期比较函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否在之前 | 其他日期 | Date\|string\|number\|日期 | 判断当前日期是否在指定日期之前 | boolean |
| 是否在之后 | 其他日期 | Date\|string\|number\|日期 | 判断当前日期是否在指定日期之后 | boolean |
| 是否相等 | 其他日期 | Date\|string\|number\|日期 | 判断当前日期是否与指定日期相等 | boolean |

**静态方法** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 当前 | 无 | 无 | 获取当前日期实例 | 日期实例 |
| 解析 | 值 | Date\|string\|number | 解析日期值为日期实例 | 日期实例 |
| 比较 | a, b | Date\|string\|number\|日期 | 比较两个日期（-1：a在b前，0：相等，1：a在b后） | number |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 日期 } = require('./zh/公共函数/zh-date.js');
// 方法2: 直接导入日期构造函数
const 日期 = require('./zh/公共函数/zh-date.js').日期;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 日期 } from './zh/公共函数/zh-date.js';
// 方法2: 使用默认导入
import 日期 from './zh/公共函数/zh-date.js';
```

**基本使用示例:**
```javascript
// 创建日期并链式调用（使用 new 关键字）
const tomorrow = new 日期()
  .加天数(1)
  .格式化('YYYY年MM月DD日');
console.log(tomorrow); // 例如: 2024年01月16日

// 或者使用静态方法获取当前日期
const today = 日期.当前();

// 日期比较（使用 new 关键字）
const isAfter = new 日期('2024-01-16').是否在之后('2024-01-15'); // true

// 静态方法比较（静态方法不需要 new 关键字）
const comparison = 日期.比较('2024-01-15', '2024-01-16'); // -1
```

#### 函数操作中文封装

**模块信息**
- 模块文件名: zh-function.js
- 路径: zh/公共函数/zh-function.js
- 功能: 提供JavaScript函数的中文API封装，支持函数操作、延迟执行、节流、防抖等功能

**核心特性**
- 所有操作均返回新函数实例，不修改原函数
- 完整支持链式调用
- 提供JSDoc参数提示
- 包含常用函数增强功能

**命令总数：17个**

**基础函数操作** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 函数 | Function | 创建函数封装实例 | 函数实例 |
| 取值 | 无 | 无 | 获取原始函数 | Function |
| 调用 | 上下文, ...参数 | *, ...* | 调用函数 | * |

**函数增强操作** (9个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 延迟执行 | 延迟毫秒, ...参数 | number, ...* | 延迟执行函数 | { 清除: Function } |
| 节流 | 间隔毫秒, 立即执行 = true | number, boolean | 创建节流函数 | 函数实例 |
| 防抖 | 等待毫秒, 立即执行 = false | number, boolean | 创建防抖函数 | 函数实例 |
| 绑定 | 上下文, ...前置参数 | *, ...* | 绑定函数上下文 | 函数实例 |
| 前置包装 | 前置函数 | Function | 前置包装函数 | 函数实例 |
| 后置包装 | 后置函数 | Function | 后置包装函数 | 函数实例 |
| 重试 | 最大次数, 间隔毫秒 = 1000 | number, number | 创建重试函数 | 函数实例 |
| 缓存 | 无 | 无 | 创建结果缓存函数 | 函数实例 |
| 超时控制 | 超时毫秒, 超时错误 = new Error('函数执行超时') | number, Error | 创建带超时控制的函数 | 函数实例 |

**静态方法** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否函数 | v | any | 判断是否为函数 | boolean |
| 空 | 无 | 无 | 创建空函数 | 函数实例 |
| 恒等 | 无 | 无 | 创建恒等函数 | 函数实例 |
| 组合 | ...函数列表 | Function... | 组合函数（从右到左） | 函数实例 |
| 管道 | ...函数列表 | Function... | 管道函数（从左到右） | 函数实例 |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 函数 } = require('./zh/公共函数/zh-function.js');
// 方法2: 直接导入函数构造函数
const 函数 = require('./zh/公共函数/zh-function.js').函数;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 函数 } from './zh/公共函数/zh-function.js';
// 方法2: 使用默认导入
import 函数 from './zh/公共函数/zh-function.js';
```

**基本使用示例:**
```javascript
// 创建函数并调用（使用 new 关键字）
const 加法函数 = new 函数((a, b) => a + b);
const 结果 = 加法函数.调用(null, 5, 3);
console.log(结果); // 8

// 链式调用 - 创建节流函数
const 节流函数 = new 函数(() => console.log('执行操作'))
  .节流(1000, true);

// 函数组合（使用静态方法，无需 new 关键字）
const 转大写 = str => str.toUpperCase();
const 添加感叹号 = str => str + '!';
const 添加前缀 = str => `Hello, ${str}`;

const 组合结果 = 函数.组合(转大写, 添加感叹号, 添加前缀)
  .调用(null, 'world');
console.log(组合结果); // "HELLO, WORLD!"

// 函数管道（使用静态方法，无需 new 关键字）
const 管道结果 = 函数.管道(添加前缀, 添加感叹号, 转大写)
  .调用(null, 'world');
console.log(管道结果); // "HELLO, WORLD!"
```

#### 堆操作中文封装

**模块信息**
- 模块文件名: zh-heap.js
- 路径: zh/公共函数/zh-heap.js
- 功能: 提供堆数据结构的中文API封装，支持最大堆、最小堆、优先级队列和链式调用

**核心特性**
- 所有操作均返回堆实例以支持链式调用
- 提供JSDoc参数提示
- 支持自定义比较函数
- 包含堆的完整操作和扩展功能

**命令总数：29个**

**基础操作函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 初始数据 = [], 比较函数 = (a,b)=>a-b | Array, Function | 创建堆实例 | 堆实例 |
| 取值 | 无 | 无 | 获取堆数据数组的副本 | Array |
| 大小 | 无 | 无 | 获取堆中元素数量 | number |
| 是否为空 | 无 | 无 | 判断堆是否为空 | boolean |
| 清空 | 无 | 无 | 清空堆中的所有元素 | 堆实例 |
| 查看堆顶 | 无 | 无 | 查看堆顶元素但不移除 | * |
| 插入 | 元素 | * | 向堆中插入一个元素 | 堆实例 |
| 批量插入 | 元素数组 | Array | 批量插入多个元素 | 堆实例 |

**元素操作函数** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 弹出堆顶 | 无 | 无 | 移除并返回堆顶元素 | * |
| 替换堆顶 | 元素 | * | 替换堆顶元素并调整堆 | * |
| 更新元素 | 索引, 新元素 | number, * | 更新指定索引位置的元素 | 堆实例 |
| 移除元素 | 索引 | number | 移除指定索引位置的元素 | * |
| 查找元素 | 元素, 相等函数 = (a,b)=>a===b | *, Function | 查找指定元素在堆中的索引 | number |
| 克隆 | 无 | 无 | 创建当前堆的深拷贝 | 堆实例 |
| 排序 | 无 | 无 | 将堆转换为有序数组 | Array |

**扩展功能函数** (9个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 转字符串 | 分隔符 = ', ' | string | 将堆转换为字符串 | string |
| 遍历 | 回调 | Function | 遍历堆中所有元素 | 堆实例 |
| 验证堆 | 无 | 无 | 验证当前数据结构是否满足堆的性质 | boolean |
| 获取高度 | 无 | 无 | 获取堆的高度（层数） | number |
| 获取层级 | 层级 | number | 获取指定层级的所有元素 | Array |
| 执行 | 操作 | Function | 在堆数据上执行自定义操作 | 堆实例或操作结果 |
| 层级迭代 | 无 | 无 | 层级遍历迭代器 - 按存储顺序迭代 | Iterator<*> |
| Symbol.iterator | 无 | 无 | 迭代器实现 - 按堆顶弹出顺序迭代 | Iterator<*> |

**静态方法** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建最小堆 | 初始数据 = [] | Array | 静态方法：创建最小堆 | 堆实例 |
| 创建最大堆 | 初始数据 = [] | Array | 静态方法：创建最大堆 | 堆实例 |
| 创建优先队列 | 优先函数, 初始数据 = [] | Function, Array | 静态方法：创建优先队列 | 堆实例 |
| 从数组 | 数组, 比较函数 = (a,b)=>a-b | Array, Function | 静态方法：从数组创建堆 | 堆实例 |
| 是堆 | 对象 | * | 静态方法：判断对象是否是堆实例 | boolean |
| 堆排序 | 数组, 比较函数 = (a,b)=>b-a | Array, Function | 静态方法：堆排序算法 | Array |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 堆 } = require('./zh/公共函数/zh-heap.js');
// 方法2: 直接导入堆构造函数
const 堆 = require('./zh/公共函数/zh-heap.js').堆;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 堆 } from './zh/公共函数/zh-heap.js';
// 方法2: 使用默认导入
import 堆 from './zh/公共函数/zh-heap.js';
```

**基本使用示例:**
```javascript
// 创建堆并链式调用（使用 new 关键字）
const 基本堆 = new 堆()
  .插入(5)
  .插入(3)
  .插入(8);
console.log(基本堆.取值()); // 堆中的元素

// 使用静态方法创建最小堆（静态方法不需要 new 关键字）
const 最小堆 = 堆.创建最小堆([4, 1, 3, 2, 16]);
console.log(最小堆.查看堆顶()); // 1

// 创建优先队列
const 任务队列 = 堆.创建优先队列(
  (a, b) => a.优先级 - b.优先级,
  [{ id: 1, 描述: '普通任务', 优先级: 3 },
   { id: 2, 描述: '紧急任务', 优先级: 1 }]
);

// 弹出堆顶元素（优先级最高的任务）
const 任务 = 任务队列.弹出堆顶();
console.log(任务.描述); // "紧急任务"

// 堆排序
const 排序结果 = 堆.堆排序([4, 10, 3, 5, 1], (a, b) => a - b);
console.log(排序结果); // [1, 3, 4, 5, 10]
```

#### 映射操作中文封装

**模块信息**
- 模块文件名: zh-map.js
- 路径: zh/公共函数/zh-map.js
- 功能: 提供JavaScript Map的中文API封装，支持映射操作和链式调用（返回新映射，不修改原始Map）

**核心特性**
- 所有修改操作均返回新映射实例，不修改原映射
- 完整支持链式调用
- 提供JSDoc参数提示
- 支持复杂键类型（数组、对象、函数等）

**命令总数：21个**

**基础操作函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 值 = [] | Iterable<Array<*>> | 创建映射实例 | 映射实例 |
| 取值 | 无 | 无 | 获取原始Map的副本 | Map |
| 打印 | 无 | 无 | 打印映射内容到控制台 | 映射实例 |
| 添加 | 键, 值 | *, * | 添加键值对，返回新映射 | 映射实例 |
| 批量添加 | 条目数组 | Array<Array<*>> | 批量添加键值对，返回新映射 | 映射实例 |
| 删除 | 键 | * | 删除指定键的键值对，返回新映射 | 映射实例 |
| 批量删除 | ...键列表 | ...* | 批量删除多个键的键值对，返回新映射 | 映射实例 |
| 清空 | 无 | 无 | 返回空映射 | 映射实例 |

**查询与获取函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 包含 | 键 | * | 判断映射是否包含指定键 | boolean |
| 取 | 键 | * | 获取指定键对应的值 | * |
| 大小 | 无 | 无 | 获取映射中键值对数量 | number |
| 转数组 | 无 | 无 | 将映射转换为条目数组 | Array<Array<*>> |
| 取键 | 无 | 无 | 获取映射中所有的键 | Array<*> |
| 取值列表 | 无 | 无 | 获取映射中所有的值 | Array<*> |

**扩展功能函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取条目 | 无 | 无 | 获取映射中所有的条目 | Array<Array<*>> |
| 遍历 | 回调 | Function | 遍历映射中所有键值对 | 映射实例 |
| 合并 | ...映射项 | ...Map\|...映射 | 合并多个映射，返回新映射 | 映射实例 |
| 映射值 | 回调 | Function | 对映射中的每个值执行映射操作，返回新映射 | 映射实例 |
| 过滤 | 回调 | Function | 过滤映射中的键值对，返回满足条件的键值对组成的新映射 | 映射实例 |

**静态方法** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否映射 | v | * | 静态方法：判断对象是否为Map实例 | boolean |
| 创建 | 可迭代 = [] | Iterable<Array<*>> | 静态方法：创建映射 | 映射实例 |
| 从对象 | 对象 | Object | 静态方法：从普通对象创建映射 | 映射实例 |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 映射 } = require('./zh/公共函数/zh-map.js');
// 方法2: 直接导入映射构造函数
const 映射 = require('./zh/公共函数/zh-map.js').映射;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 映射 } from './zh/公共函数/zh-map.js';
// 方法2: 使用默认导入
import 映射 from './zh/公共函数/zh-map.js';
```

**基本使用示例:**
```javascript
// 创建映射并链式调用（使用 new 关键字）
const 基本映射 = new 映射()
  .添加('键1', '值1')
  .添加('键2', 2)
  .添加('键3', { 名称: '对象值' });

console.log(基本映射.大小()); // 3
console.log(基本映射.取('键2')); // 2

// 批量操作
const 批量映射 = 基本映射.批量添加([
  ['键4', 4],
  ['键5', [1, 2, 3]]
]);

// 使用静态方法（静态方法不需要 new 关键字）
const 静态创建映射 = 映射.创建([['a', 1], ['b', 2]]);
const 从对象映射 = 映射.从对象({ 名称: '测试', 版本: '1.0' });

// 映射操作（返回新映射，不修改原映射）
const 新映射 = 基本映射
  .删除('键1')
  .映射值((值) => 值 * 2) // 仅对数值生效
  .过滤((值) => typeof 值 === 'number');

// 合并映射
const 合并结果 = 基本映射.合并(静态创建映射);
```

#### 数学操作中文封装

**模块信息**
- 模块文件名: zh-math.js
- 路径: zh/公共函数/zh-math.js
- 功能: 提供JavaScript数学运算、三角函数、矩阵、向量运算、随机数生成等功能的中文API封装，支持链式调用

**核心特性**
- 完整的数学运算支持（基础运算、三角函数、指数对数等）
- 支持向量和矩阵操作
- 提供随机数生成和统计功能
- 支持链式调用
- 提供JSDoc参数提示

**命令总数：65个**

**基础数学运算函数** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 值 = 0 | number\|string | 创建数学计算实例 | 数学实例 |
| 取值 | 无 | 无 | 获取当前数值 | number |
| 设置值 | 值 | number\|string | 设置数值 | 数学实例 |
| 加 | 数值 | number\|string | 加法运算 | 数学实例 |
| 减 | 数值 | number\|string | 减法运算 | 数学实例 |
| 乘 | 数值 | number\|string | 乘法运算 | 数学实例 |
| 除 | 数值 | number\|string | 除法运算 | 数学实例 |
| 取余 | 数值 | number\|string | 取余运算 | 数学实例 |
| 幂 | 指数 | number\|string | 幂运算 | 数学实例 |
| 平方根 | 无 | 无 | 计算平方根 | 数学实例 |

**数值处理函数** (12个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 立方根 | 无 | 无 | 计算立方根 | 数学实例 |
| 取整 | 无 | 无 | 取整数部分 | 数学实例 |
| 打印 | 无 | 无 | 打印当前值到控制台 | 数学实例 |
| 转字符串 | 无 | 无 | 转换为字符串 | 数学实例 |
| 转本地字符串 | 语言 = 'zh-CN', 选项 = {} | string, Object | 转换为本地化字符串 | 数学实例 |
| 固定小数 | 位数 = 0 | number | 转换为固定小数位的字符串 | 数学实例 |
| 精度 | 位数 | number | 转换为指定精度的字符串 | 数学实例 |
| 科学记数 | 位数 | number | 转换为科学计数法字符串 | 数学实例 |
| 绝对值 | 无 | 无 | 计算绝对值 | 数学实例 |
| 向上取整 | 无 | 无 | 向上取整 | 数学实例 |
| 向下取整 | 无 | 无 | 向下取整 | 数学实例 |
| 四舍五入 | 精度 = 0 | number | 四舍五入到指定精度 | 数学实例 |

**三角函数** (12个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 弧度转角度 | 无 | 无 | 将弧度值转换为角度值 | 数学实例 |
| 角度转弧度 | 无 | 无 | 将角度值转换为弧度值 | 数学实例 |
| 正弦 | 无 | 无 | 计算正弦值（输入弧度） | 数学实例 |
| 余弦 | 无 | 无 | 计算余弦值（输入弧度） | 数学实例 |
| 正切 | 无 | 无 | 计算正切值（输入弧度） | 数学实例 |
| 反正弦 | 无 | 无 | 计算反正弦值（返回弧度） | 数学实例 |
| 反余弦 | 无 | 无 | 计算反余弦值（返回弧度） | 数学实例 |
| 反正切 | 无 | 无 | 计算反正切值（返回弧度） | 数学实例 |
| 反正切2 | y | number | 计算反正切2值（返回弧度） | 数学实例 |
| 双曲正弦 | 无 | 无 | 计算双曲正弦值 | 数学实例 |
| 双曲余弦 | 无 | 无 | 计算双曲余弦值 | 数学实例 |
| 双曲正切 | 无 | 无 | 计算双曲正切值 | 数学实例 |

**向量类方法** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 向量构造函数 | x = 0, y = 0, z = 0 | number, number, number | 创建三维向量 | 向量实例 |
| 获取长度 | 无 | 无 | 计算向量长度 | number |
| 归一化 | 无 | 无 | 归一化向量（单位向量） | 向量实例 |
| 加 | 向量 | 向量 | 向量加法 | 向量实例 |
| 减 | 向量 | 向量 | 向量减法 | 向量实例 |
| 乘 | 标量 | number | 向量与标量乘法 | 向量实例 |
| 点积 | 向量 | 向量 | 计算向量点积 | number |
| 叉积 | 向量 | 向量 | 计算向量叉积 | 向量实例 |
| 距离 | 向量 | 向量 | 计算与另一个向量的距离 | number |
| 克隆 | 无 | 无 | 创建向量副本 | 向量实例 |

**矩阵类方法** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 矩阵构造函数 | 行数, 列数 | number, number | 创建矩阵 | 矩阵实例 |
| 设置值 | 行, 列, 值 | number, number, number | 设置矩阵元素值 | 矩阵实例 |
| 获取值 | 行, 列 | number, number | 获取矩阵元素值 | number\|undefined |
| 取值 | 无 | 无 | 获取矩阵数据的深拷贝 | Array<Array<number>> |
| 克隆 | 无 | 无 | 创建矩阵副本 | 矩阵实例 |

**静态方法** (16个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建 | 值 = 0 | number\|string | 静态方法：创建数学实例 | 数学实例 |
| 距离 | x1, y1, x2, y2 | number, number, number, number | 静态方法：计算两点之间的距离 | number |
| 向量长度 | x, y | number, number | 静态方法：计算二维向量长度 | number |
| 向量点积 | x1, y1, x2, y2 | number, number, number, number | 静态方法：计算二维向量点积 | number |
| 向量叉积 | x1, y1, x2, y2 | number, number, number, number | 静态方法：计算二维向量叉积 | number |
| 归一化向量 | x, y | number, number | 静态方法：归一化二维向量 | Object |
| 随机数 | 最小值 = 0, 最大值 = 1 | number, number | 静态方法：生成随机浮点数 | number |
| 随机整数 | 最小值 = 0, 最大值 = 1 | number, number | 静态方法：生成随机整数 | number |
| 随机布尔值 | 无 | 无 | 静态方法：生成随机布尔值 | boolean |
| 随机字符串 | 长度 = 8, 字符集 = 'abcdefghijklmnopqrstuvwxyz<br>ABCDEFGHIJKLMNOPQRSTUVWXYZ<br>0123456789' | number, string | 静态方法：生成随机字符串 | string |
| 矩阵乘法 | 矩阵A, 矩阵B | Array<Array<number>>, Array<Array<number>> | 静态方法：矩阵乘法运算 | Array<Array<number>> |
| 矩阵加法 | 矩阵A, 矩阵B | Array<Array<number>>, Array<Array<number>> | 静态方法：矩阵加法运算 | Array<Array<number>> |
| 矩阵标量乘法 | 矩阵, 标量 | Array<Array<number>>, number | 静态方法：矩阵与标量乘法 | Array<Array<number>> |
| 创建单位矩阵 | 大小 | number | 静态方法：创建单位矩阵 | Array<Array<number>> |
| 平均值 | ...数值 | ...number | 静态方法：计算平均值 | number |
| 中位数 | ...数值 | ...number | 静态方法：计算中位数 | number |

**使用示例**

**CommonJS 导入:**
```javascript
// 导入数学类
const { 数学, 向量, 矩阵 } = require('./zh/公共函数/zh-math.js');
// 直接导入构造函数
const 数学 = require('./zh/公共函数/zh-math.js').数学;
```

**ES 模块导入:**
```javascript
// 导入数学类
import { 数学, 向量, 矩阵 } from './zh/公共函数/zh-math.js';
// 使用默认导入
import 数学 from './zh/公共函数/zh-math.js';
```

**基本使用示例:**
```javascript
// 创建数学实例并链式调用（使用 new 关键字）
const 计算结果 = new 数学(10)
  .加(5)
  .乘(2)
  .除(3)
  .四舍五入(2);

console.log(计算结果.取值()); // 10

// 三角函数计算
const 角度 = new 数学(90)
  .角度转弧度()
  .正弦()
  .取值();

  console.log(角度); // 1

  // 使用静态方法（静态方法不需要 new 关键字）
  const 随机数 = 数学.随机数(1, 100);
  const 两点距离 = 数学.距离(0, 0, 3, 4); // 5

  // 向量操作
  const 向量1 = new 向量(1, 2, 3);
  const 向量2 = new 向量(4, 5, 6);
  const 向量和 = 向量1.克隆().加(向量2);
  const 点积结果 = 向量1.点积(向量2);

  // 矩阵操作
  const 矩阵1 = new 矩阵(2, 2);
  矩阵1
    .设置值(0, 0, 1)
    .设置值(0, 1, 2)
    .设置值(1, 0, 3)
    .设置值(1, 1, 4);

  // 使用静态方法进行矩阵运算
  const 单位矩阵 = 数学.创建单位矩阵(3);
  const 旋转矩阵 = 数学.创建旋转矩阵(45);

  // 统计功能
  const 平均值 = 数学.平均值(1, 2, 3, 4, 5); // 3
  const 中位数 = 数学.中位数(1, 3, 5, 7, 9); // 5
```

#### 对象操作中文封装

**模块信息**
- 模块文件名: zh-object.js
- 路径: zh/公共函数/zh-object.js
- 功能: 提供JavaScript对象的中文API封装，支持ES6+ Object所有操作和链式调用（返回新对象，不修改原始对象）

**核心特性**
- 所有操作均返回新对象实例，不修改原对象
- 完整支持链式调用
- 提供JSDoc参数提示
- 包含常用扩展工具方法

**命令总数：27个**

**基础操作函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 值 = {} | Object | 创建对象实例 | 对象实例 |
| 取值 | 无 | 无 | 获取原始对象的浅拷贝 | Object |
| 打印 | 无 | 无 | 打印当前对象到控制台 | 对象实例 |
| 取键 | 无 | 无 | 获取对象所有可枚举属性的键名 | Array<string> |
| 取值列表 | 无 | 无 | 获取对象所有可枚举属性的值 | Array<any> |
| 取条目 | 无 | 无 | 获取对象所有可枚举属性的键值对 | Array<Array<string, any>> |

**属性操作函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取属性描述 | 键 | string | 获取指定属性的属性描述符 | Object|null |
| 是否自有属性 | 键 | string | 检查对象是否拥有指定的自有属性 | boolean |
| 定义属性 | 键, 描述 | string, Object | 定义或修改对象的属性 | 对象实例 |

**对象修改函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 删除属性 | 键 | string | 删除对象的指定属性 | 对象实例 |
| 合并 | ...对象列表 | ...Object\|...对象 | 合并多个对象到当前对象 | 对象实例 |
| 克隆 | 无 | 无 | 创建对象的浅拷贝 | 对象实例 |
| 冻结 | 无 | 无 | 冻结对象，使其不可修改 | 对象实例 |
| 密封 | 无 | 无 | 密封对象，使其不可添加或删除属性 | 对象实例 |

**对象状态函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 判断可扩展 | 无 | 无 | 判断对象是否可扩展 | boolean |
| 判断冻结 | 无 | 无 | 判断对象是否冻结 | boolean |
| 扩展 | 源对象 | Object\|对象 | 扩展对象（浅合并） | 对象实例 |

**对象转换函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 映射值 | 回调 | Function | 对对象的每个值应用映射函数 | 对象实例 |
| 过滤键 | 回调 | Function | 根据回调函数过滤对象的键 | 对象实例 |
| 转JSON | 缩进 = 2 | number\|string | 将对象转换为JSON字符串 | string |
| 转字符串 | 无 | 无 | 将对象转换为字符串表示 | string |

**对象扩展函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取深拷贝 | 无 | 无 | 创建对象的深拷贝 | 对象实例 |
| 取路径值 | 路径 | string | 获取对象深层属性值（支持点号路径 a.b.c） | any |
| 设路径值 | 路径, 值 | string, any | 设置对象深层属性值（支持点号路径 a.b.c） | 对象实例 |

**静态方法** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否对象 | v | any | 判断值是否为对象 | boolean |
| 从条目 | 条目数组 | Array<Array<string, any>> | 从键值对数组创建对象 | 对象实例 |
| 创建 | 原型 = Object.prototype | Object|null | 创建具有指定原型的对象 | 对象实例 |
| 键 | 对象实例 | Object | 获取对象所有键名 | Array<string> |
| 值 | 对象实例 | Object | 获取对象所有值 | Array<any> |
| 条目 | 对象实例 | Object | 获取对象所有键值对 | Array<Array<string, any>> |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 对象 } = require('./zh/公共函数/zh-object.js');
// 方法2: 直接导入对象构造函数
const 对象 = require('./zh/公共函数/zh-object.js').对象;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 对象 } from './zh/公共函数/zh-object.js';
// 方法2: 使用默认导入
import 对象 from './zh/公共函数/zh-object.js';
```

**基本使用示例:**
```javascript
// 创建对象并链式调用（使用 new 关键字）
const 基本对象 = new 对象({ 名称: '测试', 版本: '1.0' })
  .合并({ 作者: '开发者' })
  .映射值(v => typeof v === 'string' ? v.toUpperCase() : v)
  .取值();

console.log(基本对象); // { 名称: '测试', 版本: '1.0', 作者: '开发者' }

// 深层属性操作
const 复杂对象 = new 对象({
  用户: {
    信息: {
      名称: '张三',
      年龄: 30
    }
  }
});

const 名称 = 复杂对象.取路径值('用户.信息.名称'); // '张三'
const 更新后的对象 = 复杂对象.设路径值('用户.信息.年龄', 31).取值();

// 使用静态方法（静态方法不需要 new 关键字）
const 空对象 = 对象.创建();
const 从条目对象 = 对象.从条目([['a', 1], ['b', 2]]);
const 是否为对象 = 对象.是否对象({}); // true

// 对象过滤和映射
const 过滤后的对象 = new 对象({
  a: 1,
  b: '字符串',
  c: true,
  d: 4
}).过滤键((k, v) => typeof v === 'number');

// JSON转换
const json字符串 = new 对象({ x: 1, y: 2 }).转JSON(2);
```


#### 异步操作中文封装

**模块信息**
- 模块文件名: zh-promise.js
- 路径: zh/公共函数/zh-promise.js
- 功能: Promise异步操作中文封装，支持链式调用和常用工具方法

**核心特性**
- 完全支持 Promise 异步操作的中文方法命名
- 支持方法链式调用，提高代码可读性
- 提供常用异步操作工具方法（并行、串行、延迟、重试、超时等）
- 同时支持 CommonJS 和 ES 模块导入方式

**命令总数：18个**

**基础操作函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 执行函数 | Function | 创建异步操作实例 | 异步实例 |
| 取值 | 无 | 无 | 获取原始Promise对象 | Promise对象 |
| 等待 | 无 | 无 | 获取内部Promise（可用于await） | Promise对象 |
| 成功 | 回调 | Function | 添加成功回调处理 | 异步实例（支持链式调用） |
| 失败 | 回调 | Function | 添加失败回调处理 | 异步实例（支持链式调用） |
| 总是 | 回调 | Function | 添加最终回调处理 | 异步实例（支持链式调用） |

**实例方法** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 延迟 | 毫秒 | number | 创建指定延迟的异步操作 | 异步实例 |
| 映射 | 回调 | Function | 映射Promise的结果值到新值 | 异步实例（支持链式调用） |
| 捕获错误 | 回调 | Function | 捕获前序操作中的错误并返回新状态 | 异步实例 |

**静态方法** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 成功 | 值 = undefined | * | 静态方法：创建已成功完成的异步操作 | 异步实例 |
| 失败 | 错误 | Error\|* | 静态方法：创建已失败的异步操作 | 异步实例 |
| 并行 | 异步列表 | Array<Promise\|异步> | 静态方法：并行执行多个异步操作 | 异步实例 |
| 任一 | 异步列表 | Array<Promise\|异步> | 静态方法：并行执行多个异步操作，任一完成即返回 | 异步实例 |
| 所有 | 异步列表 | Array<Promise\|异步> | 静态方法：并行执行所有异步操作，返回所有结果状态 | 异步实例 |
| 串行 | 异步函数列表, 初始值 = undefined | Array<Function>, * | 静态方法：串行执行异步函数列表 | 异步实例 |
| 延迟 | 毫秒, 值 = undefined | number, * | 静态方法：创建延迟执行的异步操作 | 异步实例 |
| 重试 | 异步函数, 最大次数, 间隔毫秒 = 1000 | Function, number, number | 静态方法：自动重试异步操作 | 异步实例 |
| 超时 | 异步操作, 超时毫秒, 超时错误 | Promise\|Function\|*, number, Error | 静态方法：为异步操作添加超时控制 | 异步实例 |
| 包装 | 同步函数 | Function | 静态方法：将同步函数包装为异步操作 | 异步实例 |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 异步 } = require('./zh/公共函数/zh-promise.js');
// 方法2: 直接导入异步构造函数
const 异步 = require('./zh/公共函数/zh-promise.js').异步;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 异步 } from './zh/公共函数/zh-promise.js';
// 方法2: 使用默认导入
import 异步 from './zh/公共函数/zh-promise.js';
```

**基本使用示例:**

```javascript
// 创建异步操作
const 异步实例 = new 异步((resolve, reject) => {
  setTimeout(() => {
    resolve('操作成功');
  }, 1000);
});

// 链式调用
异步实例
  .成功(结果 => {
    console.log('成功:', 结果);
    return 结果 + ' 处理后';
  })
  .映射(值 => 值.toUpperCase())
  .失败(错误 => {
    console.error('失败:', 错误);
  })
  .总是(() => {
    console.log('操作完成');
  });

// 使用静态方法
// 并行执行多个异步操作
const 并行结果 = await 异步.并行([
  异步.延迟(1000, '任务1'),
  异步.延迟(1500, '任务2'),
  异步.延迟(500, '任务3')
]).等待();

// 串行执行异步函数
const 串行结果 = await 异步.串行([
  (prev) => { console.log(prev); return '第一步'; },
  (prev) => { console.log(prev); return '第二步'; },
  (prev) => { console.log(prev); return '第三步'; }
], '初始值').等待();

// 带重试的异步操作
异步.重试(
  async () => {
    // 可能失败的操作
    const result = await someUnreliableOperation();
    return result;
  },
  3, // 最多重试3次
  2000 // 每次重试间隔2秒
).成功(console.log).失败(console.error);

// 带超时控制的异步操作
异步.超时(
  someLongOperation(),
  5000, // 5秒超时
  new Error('操作超时，请稍后再试')
).成功(console.log).失败(console.error);
```

#### 队列操作中文封装

**模块信息**
- 模块文件名: zh-queue.js
- 路径: zh/公共函数/zh-queue.js
- 功能: 提供JavaScript队列数据结构的中文API封装，支持队列的基本操作、链式调用和迭代器

**核心特性**
- 支持队列的基本操作（入队、出队、查看等）
- 完整支持链式调用
- 提供JSDoc参数提示
- 内置迭代器支持
- 支持批量操作和高级功能

**命令总数：30个**

**基础操作函数** (11个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 初始数据 = [] | Array | 创建队列实例 | 队列实例 |
| 取值 | 无 | 无 | 获取队列数据数组的副本 | Array |
| 入队 | ...元素 | ...* | 添加元素到队尾 | 队列实例 |
| 出队 | 无 | 无 | 移除并返回队首元素 | * |
| 查看队首 | 无 | 无 | 查看队首元素但不移除 | * |
| 查看队尾 | 无 | 无 | 查看队尾元素但不移除 | * |
| 大小 | 无 | 无 | 获取队列中元素数量 | number |
| 是否为空 | 无 | 无 | 判断队列是否为空 | boolean |
| 清空 | 无 | 无 | 清空队列中的所有元素 | 队列实例 |
| 克隆 | 无 | 无 | 创建当前队列的深拷贝 | 队列实例 |
| 转字符串 | 分隔符 = ', ' | string | 将队列转换为字符串 | string |

**查询与访问函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 查找索引 | 元素 | * | 查找指定元素在队列中的索引 | number |
| 包含 | 元素 | * | 判断队列是否包含指定元素 | boolean |
| 获取 | 索引 | number | 获取指定索引位置的元素 | * |
| 最大值 | 比较函数 | Function | 获取队列中的最大值 | * |
| 最小值 | 比较函数 | Function | 获取队列中的最小值 | * |

**批量与扩展操作函数** (9个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 遍历 | 回调 | Function | 遍历队列中所有元素 | 队列实例 |
| 批量入队 | 元素数组 | Array | 批量将多个元素入队 | 队列实例 |
| 批量出队 | 数量 | number | 批量出队指定数量的元素 | Array |
| 映射 | 回调 | Function | 对队列中每个元素执行映射操作，返回新队列 | 队列实例 |
| 过滤 | 回调 | Function | 过滤队列中元素，返回满足条件的元素组成的新队列 | 队列实例 |
| 归约 | 回调, 初始值 | Function, * | 对队列中元素执行归约操作 | * |
| 排序 | 比较函数 | Function | 对队列中元素进行排序，返回新队列 | 队列实例 |
| 执行 | 操作 | Function | 在队列数据上执行自定义操作 | 队列实例或操作结果 |
| [Symbol.iterator] | 无 | 无 | 迭代器实现（先进先出顺序） | Generator |

**静态方法** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建 | 无 | 无 | 静态方法：创建空队列 | 队列实例 |
| 从数组 | 数组 | Array | 静态方法：从数组创建队列 | 队列实例 |
| 合并 | ...队列列表 | ...队列 | 静态方法：合并多个队列 | 队列实例 |
| 是队列 | 对象 | * | 静态方法：判断对象是否是队列实例 | boolean |
| 创建优先队列 | 比较函数 = (a,b)=>a-b | Function | 静态方法：创建优先队列 | 队列实例 |
| 检查循环依赖 | 节点, 依赖函数 | *, Function | 静态方法：检查节点间的循环依赖 | boolean |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 队列 } = require('./zh/公共函数/zh-queue.js');
// 方法2: 直接导入队列构造函数
const 队列 = require('./zh/公共函数/zh-queue.js').队列;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 队列 } from './zh/公共函数/zh-queue.js';
// 方法2: 使用默认导入
import 队列 from './zh/公共函数/zh-queue.js';
```

**基本使用示例:**
```javascript
// 创建队列并链式调用
const 基本队列 = new 队列([1, 2, 3])
  .入队(4, 5)
  .入队(6);

console.log(基本队列.大小()); // 6
console.log(基本队列.查看队首()); // 1
console.log(基本队列.出队()); // 1
console.log(基本队列.大小()); // 5

// 批量操作
const 批量队列 = 基本队列.批量入队([7, 8, 9]);
const 出队结果 = 批量队列.批量出队(2); // [2, 3]

// 数据处理操作
const 处理后的队列 = 基本队列
  .过滤(元素 => 元素 > 3)
  .映射(元素 => 元素 * 2)
  .排序();

// 使用迭代器
for (const 元素 of 基本队列) {
  console.log(元素);
}

// 静态方法使用
const 空队列 = 队列.创建();
const 数组队列 = 队列.从数组([10, 20, 30]);
const 合并队列 = 队列.合并(基本队列, 数组队列);

// 优先队列示例
const 优先队列 = 队列.创建优先队列((a, b) => b - a); // 降序优先
优先队列.入队(5, 1, 9, 3);
console.log(优先队列.出队()); // 9
console.log(优先队列.出队()); // 5
```

#### 集合操作中文封装

**模块信息**
- 模块文件名: zh-set.js
- 路径: zh/公共函数/zh-set.js
- 功能: 提供JavaScript Set集合的中文API封装，支持集合操作和链式调用（返回新集合，不修改原始Set）

**核心特性**
- 所有修改操作均返回新集合实例，不修改原集合
- 完整支持链式调用
- 提供JSDoc参数提示
- 支持集合运算（并集、交集、差集、补集）

**命令总数：17个**

**基础操作函数** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 值 = [] | Iterable | 创建集合实例 | 集合实例 |
| 取值 | 无 | 无 | 获取原始Set的副本 | Set |
| 打印 | 无 | 无 | 打印集合内容到控制台 | 集合实例 |
| 添加 | ...元素 | ...* | 添加元素到集合，返回新集合 | 集合实例 |
| 删除 | 元素 | * | 从集合删除元素，返回新集合 | 集合实例 |
| 包含 | 元素 | * | 判断集合是否包含指定元素 | boolean |
| 清空 | 无 | 无 | 返回空集合 | 集合实例 |
| 大小 | 无 | 无 | 获取集合中元素数量 | number |
| 转数组 | 无 | 无 | 将集合转换为数组 | Array |
| 转字符串 | 无 | 无 | 将集合转换为字符串 | string |

**集合运算函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 并集 | ...集合项 | ...Set\|...集合 | 计算当前集合与其他集合的并集 | 集合实例 |
| 交集 | ...集合项 | ...Set\|...集合 | 计算当前集合与其他集合的交集 | 集合实例 |
| 差集 | ...集合项 | ...Set\|...集合 | 计算当前集合与其他集合的差集 | 集合实例 |
| 补集 | ...集合项 | ...Set\|...集合 | 计算当前集合与其他集合的补集 | 集合实例 |

**遍历函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 遍历 | 回调 | Function | 遍历集合中所有元素 | 集合实例 |

**静态方法** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否集合 | v | * | 静态方法：判断对象是否为Set实例 | boolean |
| 创建 | 可迭代 = [] | Iterable | 静态方法：创建集合 | 集合实例 |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 集合 } = require('./zh/公共函数/zh-set.js');
// 方法2: 直接导入集合构造函数
const 集合 = require('./zh/公共函数/zh-set.js').集合;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 集合 } from './zh/公共函数/zh-set.js';
// 方法2: 使用默认导入
import 集合 from './zh/公共函数/zh-set.js';
```

**基本使用示例:**
```javascript
// 创建集合并链式调用
const 基本集合 = new 集合([1, 2, 3])
  .添加(4, 5)
  .添加(6);

console.log(基本集合.大小()); // 6
console.log(基本集合.包含(3)); // true

// 删除元素（返回新集合，不修改原集合）
const 新集合 = 基本集合.删除(3);
console.log(基本集合.包含(3)); // true
console.log(新集合.包含(3)); // false

// 集合运算
const 集合A = new 集合([1, 2, 3, 4]);
const 集合B = new 集合([3, 4, 5, 6]);

const 并集结果 = 集合A.并集(集合B); // {1, 2, 3, 4, 5, 6}
const 交集结果 = 集合A.交集(集合B); // {3, 4}
const 差集结果 = 集合A.差集(集合B); // {1, 2}
const 补集结果 = 集合A.补集(集合B); // {1, 2, 5, 6}

// 转换操作
console.log(集合A.转数组()); // [1, 2, 3, 4]
console.log(集合A.转字符串()); // "1,2,3,4"

// 遍历操作
集合A.遍历(元素 => {
  console.log(元素);
});

// 静态方法使用
const 空集合 = 集合.创建();
const 数组集合 = 集合.创建([7, 8, 9]);
console.log(集合.是否集合(数组集合)); // true
```

#### 栈操作中文封装

**模块信息**
- 模块文件名: zh-stack.js
- 路径: zh/公共函数/zh-stack.js
- 功能: 提供JavaScript栈数据结构的中文API封装，支持栈的基本操作、链式调用、迭代器和栈特定算法

**核心特性**
- 完整支持链式调用
- 提供JSDoc参数提示
- 支持迭代器和生成器
- 内置括号匹配算法

**命令总数：26个**

**基础操作函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 初始数据 = [] | Array | 创建栈实例 | 栈实例 |
| 取值 | 无 | 无 | 获取栈数据数组的副本 | Array |
| 入栈 | 元素 | * | 入栈操作 | 栈实例 |
| 出栈 | 无 | 无 | 出栈操作 | * |
| 查看栈顶 | 无 | 无 | 查看栈顶元素但不移除 | * |
| 大小 | 无 | 无 | 获取栈的大小 | number |
| 是否为空 | 无 | 无 | 判断栈是否为空 | boolean |
| 清空 | 无 | 无 | 清空栈 | 栈实例 |

**遍历与转换函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 遍历 | 回调 | Function | 遍历栈中的所有元素 | 栈实例 |
| 反向遍历 | 回调 | Function | 反向遍历栈中的所有元素 | 栈实例 |
| 映射 | 回调 | Function | 映射操作，返回新数组 | Array |
| 过滤 | 回调 | Function | 过滤操作，返回新数组 | Array |
| 归约 | 回调, 初始值 | Function, any | 归约操作，从左到右 | any |
| 转字符串 | 无 | 无 | 转换为字符串 | string |
| 转JSON | 无 | 无 | 转换为JSON字符串 | string |
| 复制 | 无 | 无 | 复制栈实例 | 栈实例 |

**查询函数** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 查找 | 回调 | Function | 查找元素，返回第一个匹配的元素 | any |
| 查找索引 | 回调 | Function | 查找元素索引，返回第一个匹配的元素索引 | number |
| 包含 | 元素 | * | 判断是否包含指定元素 | boolean |
| 所有满足 | 回调 | Function | 判断是否所有元素都满足条件 | boolean |
| 存在满足 | 回调 | Function | 判断是否至少有一个元素满足条件 | boolean |
| 迭代器 | 无 | 无 | Symbol.iterator实现 | Iterator |
| 生成器 | 无 | 无 | 生成器方法，用于for...of循环 | Generator |

**静态方法** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 从JSON | jsonString | string | 从JSON字符串创建栈实例 | 栈实例 |
| 创建 | ...元素 | ...* | 创建新的栈实例 | 栈实例 |
| 括号匹配 | 表达式 | string | 静态方法：检查括号是否匹配 | boolean |

**使用示例**

**CommonJS 导入:**
```javascript
// 方法1: 导入整个模块
const { 栈 } = require('./zh/公共函数/zh-stack.js');
// 方法2: 直接导入栈构造函数
const 栈 = require('./zh/公共函数/zh-stack.js').栈;
```

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 栈 } from './zh/公共函数/zh-stack.js';
// 方法2: 使用默认导入
import 栈 from './zh/公共函数/zh-stack.js';
```

**基本使用示例:**
```javascript
// 创建栈并链式调用
const 基本栈 = new 栈([1, 2, 3])
  .入栈(4)
  .入栈(5);

console.log(基本栈.大小()); // 5
console.log(基本栈.查看栈顶()); // 5
console.log(基本栈.出栈()); // 5
console.log(基本栈.大小()); // 4

// 判断栈状态
console.log(基本栈.是否为空()); // false
基本栈.清空();
console.log(基本栈.是否为空()); // true

// 遍历操作
const 数据栈 = new 栈(['a', 'b', 'c']);
数据栈.遍历((元素, 索引) => {
  console.log(`索引 ${索引}: ${元素}`);
});

// 反向遍历
数据栈.反向遍历((元素, 索引) => {
  console.log(`反向索引 ${索引}: ${元素}`);
});

// 数据处理方法
const 数字栈 = new 栈([1, 2, 3, 4, 5]);
const 平方栈 = 数字栈.映射(x => x * x); // [1, 4, 9, 16, 25]
const 偶数栈 = 数字栈.过滤(x => x % 2 === 0); // [2, 4]
const 和 = 数字栈.归约((累计, 当前) => 累计 + 当前, 0); // 15

// 查询方法
console.log(数字栈.包含(3)); // true
console.log(数字栈.查找(x => x > 3)); // 4
console.log(数字栈.查找索引(x => x > 3)); // 3
console.log(数字栈.所有满足(x => x > 0)); // true
console.log(数字栈.存在满足(x => x > 10)); // false

// 迭代器使用
for (const 元素 of 数据栈) {
  console.log(元素);
}

// 生成器使用
for (const 元素 of 数据栈.生成器()) {
  console.log(元素);
}

// 转换操作
console.log(数字栈.转字符串()); // "1,2,3,4,5"
const jsonStr = 数字栈.转JSON();
console.log(jsonStr); // "[1,2,3,4,5]"

// 从JSON创建
const 从JSON创建的栈 = 栈.从JSON('[6,7,8,9,10]');
console.log(从JSON创建的栈.大小()); // 5

// 静态创建方法
const 静态创建栈 = 栈.创建(11, 12, 13);
console.log(静态创建栈.大小()); // 3

// 括号匹配算法示例
console.log(栈.括号匹配('(){}[]')); // true
console.log(栈.括号匹配('([)]')); // false
console.log(栈.括号匹配('{[()]}')); // true
console.log(栈.括号匹配('{[(])}')); // false
console.log(栈.括号匹配('()')); // true
console.log(栈.括号匹配('(')); // false
```
#### 字符串操作中文封装

**模块信息**
- 模块文件名: zh-string.js
- 路径: zh/公共函数/zh-string.js
- 功能: 提供中文字符串操作封装，支持链式调用和丰富的字符串处理方法

**核心特性**
- 支持所有标准字符串操作的中文命名封装
- 提供丰富的扩展功能，如驼峰转换、HTML转义等
- 支持链式调用，提高代码可读性
- 同时支持 CommonJS 和 ES 模块导出
- 包含完整的编码、解码、格式转换等功能
- 提供JSDoc参数提示，方便开发使用

**命令总数：80+**

**基本操作函数** (16个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 内容 = "" | string\|any | 创建字符串封装对象 | 字符串实例 |
| 值() | 无 | 无 | 获取原始字符串值 | string |
| toString() | 无 | 无 | 兼容 toString | string |
| valueOf() | 无 | 无 | 兼容 valueOf | string |
| 打印() | 无 | 无 | 打印当前值 | 字符串实例 |
| 去空格() | 无 | 无 | 去掉首尾空白 | 字符串实例 |
| 去前空格() | 无 | 无 | 去掉开头空白 | 字符串实例 |
| 去后空格() | 无 | 无 | 去掉结尾空白 | 字符串实例 |
| 大写() | 无 | 无 | 全部转为大写 | 字符串实例 |
| 小写() | 无 | 无 | 全部转为小写 | 字符串实例 |
| 首字母大写() | 无 | 无 | 仅首字母大写 | 字符串实例 |
| 首字母小写() | 无 | 无 | 仅首字母小写 | 字符串实例 |
| 反转() | 无 | 无 | 反转字符串 | 字符串实例 |
| 重复() | 次数 | number | 重复字符串n次 | 字符串实例 |
| 拼接() | ...内容 | string[] | 拼接字符串 | 字符串实例 |

**检索与判断函数** (11个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取长度() | 无 | 无 | 获取字符串长度 | number |
| 是否空() | 无 | 无 | 判断是否为空字符串 | boolean |
| 是否空白() | 无 | 无 | 判断是否全为空白 | boolean |
| 查找() | 子串, 起始=0 | string, number | 查找子串位置 | number |
| 反向查找() | 子串, 起始 | string, number | 反向查找子串 | number |
| 包含() | 子串 | string | 判断是否包含子串 | boolean |
| 以开头() | 前缀, 起始=0 | string, number | 判断是否以某前缀开始 | boolean |
| 以结尾() | 后缀, 长度 | string, number | 判断是否以某后缀结束 | boolean |
| 搜索() | 正则 | RegExp\|string | 正则搜索 | number |
| 本地比较() | 目标, locales, options | string, string[], object | 本地比较字符串 | number |

**正则与匹配** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 匹配() | 正则 | RegExp\|string | 正则匹配 | RegExpMatchArray\|null |
| 匹配所有() | 正则 | RegExp | 匹配所有并返回迭代器 | IterableIterator |
| 匹配所有数组() | 正则 | RegExp | 匹配所有并返回数组 | Array |

**替换函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 替换() | 查找, 替换为 | string\|RegExp, string\|Function | 替换子串 | 字符串实例 |
| 替换所有() | 查找, 替换为 | string\|RegExp, string\|Function | 替换所有子串 | 字符串实例 |

**截取与切分** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取子串() | 开始, 结束 | number, number | 截取子串 | 字符串实例 |
| 取子片段() | 开始, 结束 | number, number | 取片段 | 字符串实例 |
| 截取() | 起始, 长度 | number, number | 截取(旧方法) | 字符串实例 |
| 拆分() | 分隔符, 限制 | string\|RegExp, number | 拆分为数组 | string[] |
| 拆分为行() | 无 | 无 | 按行拆分 | string[] |

**字符与编码** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 取字符() | 位置 | number | 获取指定位置字符 | string |
| 取编码() | 位置 | number | 获取字符编码 | number |
| 码点取字符() | 位置 | number | 获取码点 | number\|undefined |

**填充函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 填充前() | 长度, 填充符=" " | number, string | 左填充 | 字符串实例 |
| 填充后() | 长度, 填充符=" " | number, string | 右填充 | 字符串实例 |

**扩展功能函数** (24个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 驼峰() | 无 | 无 | 转为驼峰命名 | 字符串实例 |
| 帕斯卡() | 无 | 无 | 转为帕斯卡命名 | 字符串实例 |
| 下划线() | 无 | 无 | 转为下划线命名 | 字符串实例 |
| 中划线() | 无 | 无 | 转为中划线命名 | 字符串实例 |
| 标题式() | 无 | 无 | 转为标题式 | 字符串实例 |
| 去除所有空格() | 无 | 无 | 去除所有空格 | 字符串实例 |
| 转为数组() | 无 | 无 | 转为字符数组 | string[] |
| 转为JSON() | 无 | 无 | 尝试解析为JSON | any |
| 从JSON() | 无 | 无 | 从JSON解析并覆盖 | 字符串实例 |
| 编码URI() | 无 | 无 | URL编码 | 字符串实例 |
| 编码URI组件() | 无 | 无 | URL编码组件 | 字符串实例 |
| 解码URI() | 无 | 无 | URL解码 | 字符串实例 |
| 解码URI组件() | 无 | 无 | URL解码组件 | 字符串实例 |
| 编码Base64() | 无 | 无 | Base64编码 | 字符串实例 |
| 解码Base64() | 无 | 无 | Base64解码 | 字符串实例 |
| 截断并填充() | 长度, 填充符=" " | number, string | 截断并填充 | 字符串实例 |
| 转义HTML() | 无 | 无 | HTML转义 | 字符串实例 |
| 反转义HTML() | 无 | 无 | HTML反转义 | 字符串实例 |
| 计数() | 子串 | string\|RegExp | 计数子串出现次数 | number |
| 合并空白() | 无 | 无 | 合并连续空白 | 字符串实例 |
| 包含单词() | 单词 | string | 判断是否包含完整单词 | boolean |
| 包含_忽略大小写() | 子串 | string | 忽略大小写包含 | boolean |
| 替换_忽略大小写_所有() | 查找, 替换为 | string, string | 忽略大小写替换所有 | 字符串实例 |

**静态方法** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 从编码() | ...码 | number[] | 从编码创建字符串 | 字符串实例 |
| 从码点() | ...码点 | number[] | 从码点创建字符串 | 字符串实例 |

**使用示例**

**CommonJS 导入:**
```javascript
const { 字符串 } = require('./zh/公共函数/zh-string');
```

**基本使用示例:**
```javascript
// 创建字符串实例
const 文本 = new 字符串(' Hello World! ');

// 链式调用示例
const 处理后的文本 = 文本
  .去空格()
  .首字母大写()
  .替换('World', 'JavaScript')
  .拼接('!')
  .值();

console.log(处理后的文本); // "Hello Javascript!"

// 格式转换示例
const 变量名 = new 字符串('user-name')
  .驼峰()
  .值();
console.log(变量名); // "userName"

// 编码解码示例
const url = new 字符串('https://测试.com?name=测试')
  .编码URI()
  .值();
console.log(url); // URL编码后的字符串

// 安全操作示例
const html = new 字符串('<script>alert(1)</script>')
  .转义HTML()
  .值();
console.log(html); // "&lt;script&gt;alert(1)&lt;/script&gt;"

// 静态方法使用
const 字符 = 字符串.从编码(65, 66, 67);
console.log(字符.值()); // "ABC"
```

#### 计时器操作中文封装

**模块信息**
- 模块文件名: zh-timer.js
- 路径: zh/公共函数/zh-timer.js
- 功能: 提供计时器、秒表和定时器管理器的中文封装，支持倒计时、间隔执行、链式控制等功能

**核心特性**
- 支持计时器、秒表和定时器管理器三种时间工具
- 链式调用API设计，操作流畅
- 完整的状态管理（运行中、暂停中、已停止）
- 支持回调函数和事件处理
- 提供静态方法便捷创建各类计时器
- 提供JSDoc参数提示，方便开发使用

**命令总数：57个**

**计时器命令列表** (14个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| **基础操作函数** |
| 开始() | 无 | - | 开始或继续计时 | 计时器实例（支持链式调用） |
| 暂停() | 无 | - | 暂停计时 | 计时器实例（支持链式调用） |
| 停止() | 无 | - | 停止计时并重置状态 | 计时器实例（支持链式调用） |
| 重置() | 无 | - | 重置计时器并重新开始 | 计时器实例（支持链式调用） |
| **查询与状态函数** |
| 获取状态() | 无 | - | 获取计时器的当前状态 | 字符串：'已停止'、'运行中'或'暂停中' |
| 获取剩余时间() | 无 | - | 获取剩余时间（毫秒） | 数字（毫秒） |
| 获取经过时间() | 无 | - | 获取已经经过的时间（毫秒） | 数字（毫秒） |
| **回调函数设置** |
| 回调() | 函数 | Function | 设置计时结束时的回调函数 | 计时器实例（支持链式调用） |
| 完成回调() | 函数 | Function | 设置计时完成时的回调函数 | 计时器实例（支持链式调用） |
| 更新回调() | 函数 | Function | 设置更新回调函数（倒计时模式下每秒调用） | 计时器实例（支持链式调用） |
| **静态方法** |
| 创建() | 时长, 选项 | number, Object | 创建计时器实例 | 计时器实例 |
| 倒计时() | 秒数, 选项 | number, Object | 创建倒计时器实例 | 计时器实例 |
| 间隔执行() | 间隔毫秒, 选项 | number, Object | 创建间隔执行器实例 | 计时器实例 |
| 延迟() | 延迟毫秒, 回调 | number, Function | 创建并启动延迟执行器 | 已启动的延迟执行器实例 |

**秒表命令列表** (9个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| **基础操作函数** |
| 开始() | 无 | - | 开始或继续计时 | 秒表实例（支持链式调用） |
| 暂停() | 无 | - | 暂停计时 | 秒表实例（支持链式调用） |
| 停止() | 无 | - | 停止计时并重置所有状态 | 秒表实例（支持链式调用） |
| 重置() | 无 | - | 重置秒表但保持当前状态 | 秒表实例（支持链式调用） |
| 计次() | 无 | - | 记录当前计次时间 | 数字（毫秒）或null |
| **查询函数** |
| 获取经过时间() | 无 | - | 获取经过时间（毫秒） | 数字（毫秒） |
| 获取经过时间格式化() | 格式 | string | 获取经过时间的格式化字符串 | 字符串（格式化时间） |
| 获取计次记录() | 无 | - | 获取所有计次记录 | 数组（毫秒数组） |
| 获取状态() | 无 | - | 获取秒表当前状态 | 字符串：'已停止'、'运行中'或'暂停中' |

**定时器管理器命令列表** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| **定时器管理** |
| 添加定时器() | 名称, 定时器 | string/symbol, 计时器/秒表 | 添加定时器到管理器 | 定时器管理器实例（支持链式调用） |
| 获取定时器() | 名称 | string/symbol | 获取指定名称的定时器 | 计时器/秒表实例或null |
| 移除定时器() | 名称 | string/symbol | 移除指定名称的定时器 | 定时器管理器实例（支持链式调用） |
| 清空所有定时器() | 无 | - | 清空所有定时器 | 定时器管理器实例（支持链式调用） |
| **批量操作** |
| 开始定时器() | 名称 | string/symbol | 开始指定名称的定时器 | 定时器管理器实例（支持链式调用） |
| 暂停定时器() | 名称 | string/symbol | 暂停指定名称的定时器 | 定时器管理器实例（支持链式调用） |
| 停止定时器() | 名称 | string/symbol | 停止指定名称的定时器 | 定时器管理器实例（支持链式调用） |
| 开始所有定时器() | 无 | - | 开始所有定时器 | 定时器管理器实例（支持链式调用） |
| 暂停所有定时器() | 无 | - | 暂停所有定时器 | 定时器管理器实例（支持链式调用） |
| 停止所有定时器() | 无 | - | 停止所有定时器 | 定时器管理器实例（支持链式调用） |

**使用示例**

**CommonJS 导入:**
```javascript
const { 计时器, 秒表, 定时器管理器 } = require('./zh/公共函数/zh-timer.js');
```

**基本使用示例:**
```javascript
// 创建计时器示例
const 定时器 = new 计时器(2000, { 自动开始: false, 循环: true });
定时器
  .回调(() => console.log('计时完成'))
  .开始();

// 使用静态方法创建倒计时器
const 倒计时器 = 计时器.倒计时(10, { 自动开始: true });
倒计时器
  .更新回调((剩余秒数) => console.log(`剩余 ${剩余秒数} 秒`))
  .完成回调(() => console.log('倒计时结束'));

// 秒表示例
const 秒表实例 = new 秒表();
秒表实例.开始();

// 5秒后记录计次
setTimeout(() => {
  const 时间 = 秒表实例.计次();
  console.log(`第一次计次: ${时间} 毫秒`);
  
  // 再过3秒获取格式化时间
  setTimeout(() => {
    console.log(`经过时间: ${秒表实例.获取经过时间格式化()}`);
    秒表实例.stop();
  }, 3000);
}, 5000);

// 定时器管理器示例
const 管理器 = new 定时器管理器();
管理器
  .添加定时器('定时器1', new 计时器(1000, { 循环: true }))
  .添加定时器('倒计时1', 计时器.倒计时(5))
  .添加定时器('秒表1', new 秒表())
  .开始所有定时器();

// 10秒后停止并移除指定定时器
setTimeout(() => {
  管理器.停止定时器('定时器1').移除定时器('定时器1');
}, 10000);
```

### 前端函数模块

| 导出规范 | 源码示例 | 使用场景 |
| --- | --- | --- |
| **ES Module**（默认） | `export { 数组 };`<br>`export default 数组;` | 前端 import导入


#### DOM操作中文封装

**模块信息**
- 模块文件名: zh-dom.js
- 路径: zh/前端/zh-dom.js
- 功能: 提供DOM操作的中文API封装，支持元素查找、创建、类操作、属性设置、事件处理、元素关系管理等功能

**核心特性**
- 完整支持链式调用，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持元素查找、创建、修改和删除
- 提供事件监听和触发功能
- 支持元素关系管理和位置操作
- 包含数据属性操作和样式管理

**命令总数：60个**

**元素查找与创建函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 目标 | HTMLElement\|string | 创建DOM操作实例 | DOM操作实例 |
| 查找 | 选择器 | string | 查找子元素 | DOM操作实例或null |
| 查找所有 | 选择器 | string | 查找所有子元素 | DOM操作实例数组 |
| 创建元素 | 标签名, 属性 = {}, 内容 = '' | string, Object, string\|HTMLElement\|DOM操作\|Array | 静态方法：创建元素 | DOM操作实例 |
| 取值 | 无 | 无 | 获取原始DOM元素 | HTMLElement或null |

**类操作函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 添加类 | ...类名列表 | string... | 添加类名 | DOM操作实例（链式调用） |
| 删除类 | ...类名列表 | string... | 删除类名 | DOM操作实例（链式调用） |
| 切换类 | 类名, 状态 | string, boolean | 切换类名状态 | DOM操作实例（链式调用） |
| 包含类 | 类名 | string | 判断是否包含类名 | boolean |

**内容操作函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置文本 | 文本 | string | 设置文本内容 | DOM操作实例（链式调用） |
| 获取文本 | 无 | 无 | 获取文本内容 | string |
| 设置HTML | HTML | string | 设置HTML内容 | DOM操作实例（链式调用） |
| 获取HTML | 无 | 无 | 获取HTML内容 | string |

**属性操作函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置属性 | 键, 值 | string, string | 设置属性 | DOM操作实例（链式调用） |
| 获取属性 | 键 | string | 获取属性值 | string或null |
| 删除属性 | 键 | string | 删除属性 | DOM操作实例（链式调用） |
| 有属性 | 键 | string | 判断是否有属性 | boolean |
| 设置多个属性 | 属性对象 | Object | 设置多个属性 | DOM操作实例（链式调用） |

**样式操作函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置样式 | 键, 值 | string, string | 设置样式 | DOM操作实例（链式调用） |
| 设置多个样式 | 样式对象 | Object | 设置多个样式 | DOM操作实例（链式调用） |
| 获取样式 | 键 | string | 获取计算样式 | string |

**事件处理函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 事件监听 | 事件名, 回调, 选项 = false | string, Function, boolean\|Object | 添加事件监听 | DOM操作实例（链式调用） |
| 移除事件监听 | 事件名, 回调, 选项 = false | string, Function, boolean\|Object | 移除事件监听 | DOM操作实例（链式调用） |
| 触发事件 | 事件名, 事件数据 = {} | string, Object | 触发自定义事件 | DOM操作实例（链式调用） |

**元素关系函数** (11个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 添加子元素 | 子元素 | HTMLElement\|DOM操作 | 添加子元素 | DOM操作实例（链式调用） |
| 在前面添加子元素 | 参考元素, 子元素 | HTMLElement\|DOM操作, HTMLElement\|DOM操作 | 在指定位置添加子元素 | DOM操作实例（链式调用） |
| 移除子元素 | 子元素 | HTMLElement\|DOM操作 | 移除子元素 | DOM操作实例（链式调用） |
| 移除 | 无 | 无 | 移除自身 | DOM操作实例（链式调用） |
| 克隆 | 深克隆 = true | boolean | 克隆元素 | DOM操作实例 |
| 获取父元素 | 无 | 无 | 获取父元素 | DOM操作实例或null |
| 获取子元素 | 无 | 无 | 获取所有子元素 | DOM操作实例数组 |
| 获取兄弟元素 | 无 | 无 | 获取所有兄弟元素 | DOM操作实例数组 |
| 获取前一个兄弟元素 | 无 | 无 | 获取前一个兄弟元素 | DOM操作实例或null |
| 获取后一个兄弟元素 | 无 | 无 | 获取后一个兄弟元素 | DOM操作实例或null |
| addTo | 父元素 | HTMLElement\|DOM操作 | 将自身添加到父元素 | DOM操作实例（链式调用） |

**位置与滚动函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取位置 | 无 | 无 | 获取元素位置和大小 | DOMRect |
| 是否在可视区域 | 完全在视口内 = false | boolean | 检查元素是否在可视区域内 | boolean |
| 滚动到 | 选项 = {} | Object | 滚动到元素 | DOM操作实例（链式调用） |

**焦点操作函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 聚焦 | 选项 = {} | Object | 设置焦点 | DOM操作实例（链式调用） |
| 失焦 | 无 | 无 | 移除焦点 | DOM操作实例（链式调用） |
| 有焦点 | 无 | 无 | 判断是否有焦点 | boolean |

**数据属性操作函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置数据 | 键, 值 | string, string | 设置数据属性 | DOM操作实例（链式调用） |
| 获取数据 | 键 | string | 获取数据属性 | string或undefined |
| 获取所有数据 | 无 | 无 | 获取所有数据属性 | Object |

**静态工厂方法** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 查找 | 选择器 | string | 静态方法：查找元素 | DOM操作实例 |
| 查找所有 | 选择器 | string | 静态方法：查找所有元素 | DOM操作实例数组 |

**使用示例**

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { DOM操作 } from './zh/前端/zh-dom.js';
// 方法2: 使用默认导入
import DOM操作 from './zh/前端/zh-dom.js';
```

**基本使用示例:**
```javascript
// 创建DOM操作实例（使用选择器）
const 元素 = new DOM操作('#myElement');

// 链式调用示例
元素
  .添加类('active', 'visible')
  .设置样式('color', 'red')
  .设置多个样式({
    fontSize: '16px',
    backgroundColor: '#f0f0f0'
  })
  .设置文本('Hello DOM操作!')
  .事件监听('click', () => {
    console.log('元素被点击了');
    元素.切换类('active');
  });

// 创建元素
const 新按钮 = DOM操作.创建元素('button', {
  class: 'btn btn-primary',
  id: 'myButton',
  事件: {
    click: () => console.log('按钮被点击')
  }
}, '点击我');

// 元素关系操作
const 容器 = new DOM操作('.container');
容器
  .添加子元素(新按钮)
  .查找('#myButton')
  .设置属性('disabled', 'false');

// 静态方法使用
const 所有段落 = DOM操作.查找所有('p');
所有段落.forEach(段落 => {
  段落
    .添加类('text-content')
    .设置样式('lineHeight', '1.5');
});

// 数据属性操作
const 数据元素 = new DOM操作('#dataElement');
数据元素
  .设置数据('userId', '123')
  .设置数据('userName', '张三');

const 用户ID = 数据元素.获取数据('userId');
const 所有数据 = 数据元素.获取所有数据();

// 位置和滚动操作
const 目标元素 = new DOM操作('#target');
if (目标元素.是否在可视区域()) {
  console.log('元素在可视区域内');
} else {
  目标元素.滚动到({ behavior: 'smooth' });
}

// 焦点操作
const 输入框 = new DOM操作('#inputField');
输入框.聚焦();
if (输入框.有焦点()) {
  console.log('输入框获得焦点');
}
```

#### 存储操作中文封装

**模块信息**
- 模块文件名: zh-storage.js
- 路径: zh/前端/zh-storage.js
- 功能: 提供本地存储操作的中文API封装，支持localStorage和sessionStorage，包含自动JSON序列化/反序列化、过期时间管理和链式调用

**核心特性**
- 完整支持链式调用，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 自动处理JSON序列化和反序列化
- 支持数据过期时间管理
- 提供批量操作和存储使用量计算
- 包含存储可用性检查

**命令总数：19个**

**基础操作函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | 存储对象 = localStorage | Storage | 创建存储操作实例 | 存储实例 |
| 取值 | 无 | 无 | 获取原始存储对象 | Storage |
| 存储 | 键, 值, 过期时间毫秒 | string, *, number | 存储数据到存储对象 | 存储实例（链式调用） |
| 读取 | 键 | string | 从存储对象读取数据 | * |
| 删除 | 键 | string | 删除存储对象中的数据 | 存储实例（链式调用） |

**存储管理函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 清空 | 无 | 无 | 清空存储对象中的所有数据 | 存储实例（链式调用） |
| 包含 | 键 | string | 检查存储对象中是否存在指定键 | boolean |
| 取键 | 无 | 无 | 获取存储对象中的所有键名 | Array<string> |
| 取值列表 | 无 | 无 | 获取存储对象中的所有值 | Array<any> |
| 取条目 | 无 | 无 | 获取存储对象中的所有键值对 | Array<Array<string, any>> |

**批量操作函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 批量存储 | 数据对象, 过期时间毫秒 | Object, number | 批量存储多个数据项 | 存储实例（链式调用） |
| 批量读取 | ...键列表 | ...string | 批量读取多个数据项 | Object |
| 批量删除 | ...键列表 | ...string | 批量删除多个数据项 | 存储实例（链式调用） |

**高级功能函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 大小 | 无 | 无 | 获取存储对象中的项目数量 | number |
| 存储使用量 | 无 | 无 | 获取存储对象的近似使用量（字节数） | number |
| 清空过期数据 | 无 | 无 | 清空所有过期的数据项 | 存储实例（链式调用） |

**静态方法** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 本地 | 无 | 无 | 静态方法：创建本地存储实例 | 存储实例 |
| 会话 | 无 | 无 | 静态方法：创建会话存储实例 | 存储实例 |
| 是否可用 | 存储对象 = localStorage | Storage | 静态方法：检查存储对象是否可用 | boolean |

**使用示例**

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { 存储 } from './zh/前端/zh-storage.js';
// 方法2: 使用默认导入
import 存储 from './zh/前端/zh-storage.js';
```

**基本使用示例:**
```javascript
// 创建存储实例（默认使用localStorage）
const 本地存储 = new 存储();

// 链式调用存储数据
本地存储
  .存储('用户信息', { id: 1, name: '张三' })
  .存储('设置', { theme: 'dark' }, 86400000); // 24小时后过期

// 读取数据
const 用户信息 = 本地存储.读取('用户信息');
console.log(用户信息.name); // 张三

// 检查存储是否包含键
if (本地存储.包含('设置')) {
  console.log('设置已保存');
}

// 获取存储统计信息
console.log('存储项目数:', 本地存储.大小());
console.log('存储使用量:', 本地存储.存储使用量(), '字节');

// 使用静态方法
const 会话存储 = 存储.会话();
const 存储可用 = 存储.是否可用();

// 批量操作
本地存储.批量存储({
  '缓存1': '数据1',
  '缓存2': '数据2'
});

const 批量结果 = 本地存储.批量读取('缓存1', '缓存2');
本地存储.批量删除('缓存1', '缓存2');
```
#### URL操作中文封装

**模块信息**
- 模块文件名: zh-url.js
- 路径: zh/前端/zh-url.js
- 功能: 提供URL操作的中文API封装，支持URL解析、参数管理、组件操作、编码解码等功能，支持链式调用

**核心特性**
- 完整支持链式调用，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持URL各组件的获取和设置操作
- 提供查询参数的完整管理功能
- 包含URL编码和解码工具
- 支持URL路径合并和比较功能

**命令总数：31个**

**基础URL操作函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | url = '' | string | 创建URL操作实例 | URL操作实例 |
| 取值 | 无 | 无 | 获取原始URL对象 | URL |
| 转字符串 | 无 | 无 | 获取完整URL字符串 | string |
| 获取完整路径 | 无 | 无 | 获取完整的URL路径(href) | string |

**URL组件操作函数** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取协议 | 无 | 无 | 获取URL协议 | string |
| 设置协议 | 协议 | string | 设置URL协议 | URL操作实例（链式调用） |
| 获取主机名 | 无 | 无 | 获取主机名 | string |
| 设置主机名 | 主机名 | string | 设置主机名 | URL操作实例（链式调用） |
| 获取端口 | 无 | 无 | 获取端口号 | string |
| 设置端口 | 端口 | string\|number | 设置端口号 | URL操作实例（链式调用） |
| 获取路径名 | 无 | 无 | 获取路径名 | string |
| 设置路径名 | 路径名 | string | 设置路径名 | URL操作实例（链式调用） |
| 获取锚点 | 无 | 无 | 获取URL锚点 | string |
| 设置锚点 | 锚点 | string | 设置URL锚点 | URL操作实例（链式调用） |

**查询参数操作函数** (11个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取查询字符串 | 无 | 无 | 获取查询字符串 | string |
| 设置查询字符串 | 查询字符串 | string | 设置查询字符串 | URL操作实例（链式调用） |
| 解析参数 | 无 | 无 | 解析查询参数为对象 | Object<string, string> |
| 生成参数 | 参数对象 | Object<string, string\|number> | 根据对象生成查询参数 | URL操作实例（链式调用） |
| 添加参数 | 键, 值 | string, string\|number | 添加单个查询参数 | URL操作实例（链式调用） |
| 添加多个参数 | 参数对象 | Object<string, string\|number> | 批量添加查询参数 | URL操作实例（链式调用） |
| 获取参数 | 键 | string | 获取指定参数的值 | string\|null |
| 获取参数所有值 | 键 | string | 获取指定参数的所有值 | string[] |
| 删除参数 | 键 | string | 删除指定参数 | URL操作实例（链式调用） |
| 删除多个参数 | ...键列表 | ...string | 批量删除参数 | URL操作实例（链式调用） |
| 包含参数 | 键 | string | 检查是否包含指定参数 | boolean |

**其他操作函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否相等 | 其他URL | string\|URL | 比较URL是否相等 | boolean |
| 克隆 | 无 | 无 | 创建URL操作实例的副本 | URL操作实例 |

**静态方法** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 解析查询字符串 | 查询字符串 | string | 静态方法：解析查询字符串为对象 | Object<string, string> |
| 对象转查询字符串 | 参数对象 | Object<string, string\|number> | 静态方法：将对象转换为查询字符串 | string |
| 编码/解码 | url | string | 静态方法：编码/解码URL | string |
| 编码组件/解码组件 | 组件 | string | 静态方法：编码/解码URL组件 | string |
| 合并路径 | 基础路径, 相对路径 | string, string | 静态方法：合并URL路径 | string |

**使用示例**

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { URL操作 } from './zh/前端/zh-url.js';
// 方法2: 使用默认导入
import URL操作 from './zh/前端/zh-url.js';
```

**基本使用示例:**
```javascript
// 创建URL操作实例
const url = new URL操作('https://example.com:8080/path/to/resource?name=张三&age=25#section1');

// 获取URL组件
console.log(url.获取协议()); // https:
console.log(url.获取主机名()); // example.com
console.log(url.获取端口()); // 8080
console.log(url.获取路径名()); // /path/to/resource
console.log(url.获取查询字符串()); // ?name=张三&age=25
console.log(url.获取锚点()); // #section1

// 修改URL组件（链式调用）
url
  .设置协议('https:')
  .设置主机名('api.example.com')
  .设置端口('443')
  .设置路径名('/api/v1/data')
  .设置锚点('result');

// 查询参数操作
url
  .添加参数('page', 1)
  .添加参数('limit', 10)
  .添加多个参数({ sort: 'desc', filter: 'active' });

// 获取参数值
console.log(url.获取参数('name')); // 张三
console.log(url.获取参数所有值('tag')); // []
console.log(url.解析参数()); // { name: '张三', age: '25', page: '1', limit: '10', sort: 'desc', filter: 'active' }

// 删除参数
url.delete参数('age');
url.delete多个参数('sort', 'filter');

// 检查参数是否存在
console.log(url.包含参数('name')); // true

// 完整URL字符串
console.log(url.转字符串()); // https://api.example.com:443/api/v1/data?name=张三&page=1&limit=10#result

// 克隆URL
const urlCopy = url.克隆();

// 比较URL
console.log(url.是否相等(urlCopy)); // true

// 使用静态方法
const params = URL操作.解析查询字符串('?id=123&status=active');
const queryString = URL操作.对象转查询字符串({ key: 'value', num: 123 });
const encoded = URL操作.编码('https://example.com/中文路径');
const decoded = URL操作.解码(encoded);
const encodedComponent = URL操作.编码组件('测试值=123');
const decodedComponent = URL操作.解码组件(encodedComponent);
const mergedPath = URL操作.合并路径('/api', 'users/profile'); // /api/users/profile
```
#### WebSocket操作中文封装

**模块信息**
- 模块文件名: zh-websocket.js
- 路径: zh/前端/zh-websocket.js
- 功能: 提供WebSocket连接、消息发送、事件监听、重连机制、心跳功能的中文API封装，支持链式调用

**核心特性**
- 完整支持链式调用，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 内置自动重连机制，可配置重连间隔和最大次数
- 支持心跳机制，保持连接活跃
- 完整的事件处理系统，支持自定义事件监听
- 支持JSON消息自动序列化和反序列化

**命令总数：23个**

**基础操作函数** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 构造函数 | url, 选项 = {} | string, Object | 创建WebSocket客户端实例 | WebSocket客户端实例 |
| 取值 | 无 | 无 | 获取原始WebSocket连接实例 | WebSocket|null |
| 获取状态 | 无 | 无 | 获取当前连接状态码 | number |
| 是否连接 | 无 | 无 | 检查是否处于连接状态 | boolean |
| 连接 | 无 | 无 | 连接WebSocket服务器 | WebSocket客户端（链式调用） |
| 关闭 | [代码=1000], [原因=''] | number, string | 关闭WebSocket连接 | WebSocket客户端（链式调用） |
| 获取缓冲大小 | 无 | 无 | 获取发送缓冲区大小 | number |
| 重连 | 无 | 无 | 手动触发重连 | WebSocket客户端（链式调用） |

**消息发送函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 发送 | 消息 | string\|Object | 发送消息（自动JSON序列化） | WebSocket客户端（链式调用） |
| 发送JSON | 数据 | Object | 发送JSON格式数据 | WebSocket客户端（链式调用） |
| 发送二进制 | 数据 | ArrayBuffer\|ArrayBufferView\|Blob\|string | 发送二进制数据 | WebSocket客户端（链式调用） |

**事件处理函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 监听 | 事件名, 回调 | string, Function | 添加事件监听 | WebSocket客户端（链式调用） |
| 取消监听 | 事件名, [回调] | string, Function | 移除事件监听 | WebSocket客户端（链式调用） |

**配置函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置重连配置 | 配置 | Object | 设置重连相关配置 | WebSocket客户端（链式调用） |
| 设置心跳配置 | 配置 | Object | 设置心跳相关配置 | WebSocket客户端（链式调用） |
| 升级协议 | 协议 | string\|string[] | 升级连接协议（WebSocket不支持运行时升级） | WebSocket客户端（链式调用） |

**静态方法** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是否支持 | 无 | 无 | 检查浏览器是否支持WebSocket | boolean |
| 创建安全URL | 基础URL, [参数={}] | string, Object | 创建安全的WebSocket URL（自动转换协议） | string |

**使用示例**

**ES 模块导入:**
```javascript
// 方法1: 导入整个模块
import { WebSocket客户端 } from './zh/前端/zh-websocket.js';
// 方法2: 使用默认导入
import WebSocket客户端 from './zh/前端/zh-websocket.js';
```

**基本使用示例:**
```javascript
// 创建WebSocket客户端实例
const ws = new WebSocket客户端('ws://localhost:8080/ws', {
  协议: ['protocol1'],
  重连间隔: 2000,
  最大重连次数: 3,
  心跳配置: {
    启用: true,
    间隔: 30000,
    消息: 'ping'
  }
});

// 添加事件监听
ws
  .监听('连接', (数据) => {
    console.log('WebSocket已连接');
  })
  .监听('消息', (数据) => {
    console.log('收到消息:', 数据.数据);
    console.log('原始数据:', 数据.原始数据);
  })
  .监听('错误', (数据) => {
    console.error('WebSocket错误:', 数据.错误);
  })
  .监听('关闭', (数据) => {
    console.log('WebSocket已关闭:', 数据.事件.code, 数据.事件.reason);
  })
  .监听('重连尝试', (数据) => {
    console.log(`重连尝试中... 次数: ${数据.次数}`);
  })
  .监听('发送', (数据) => {
    console.log('消息已发送:', 数据.消息);
  });

// 连接WebSocket服务器
ws.连接();

// 发送消息
ws.发送('你好，WebSocket!');
ws.发送JSON({ 类型: '消息', 内容: '这是JSON格式消息' });

// 检查连接状态
if (ws.是否连接()) {
  console.log('WebSocket已连接，状态码:', ws.获取状态());
  console.log('发送缓冲区大小:', ws.获取缓冲大小());
}

// 手动重连
ws.重连();

// 动态配置
ws
  .设置重连配置({ 重连间隔: 5000, 最大重连次数: 10 })
  .设置心跳配置({ 启用: true, 间隔: 60000, 消息: 'heartbeat' });

// 使用静态方法
if (WebSocket客户端.是否支持()) {
  const secureUrl = WebSocket客户端.创建安全URL('http://example.com/ws', { token: 'abc123' });
  console.log('安全URL:', secureUrl); // 会自动转换为wss://example.com/ws?token=abc123
}

// 关闭连接（在适当的时候）
// ws.关闭(1000, '正常关闭');
```

### 后端函数模块

| 导出规范 | 源码示例 | 使用场景 |
| --- | --- | --- |
| **CommonJS**（默认） | `module.exports = { 数组 };`<br>`module.exports.数组 = 数组;` | Node.js 原生 require |



#### 加密操作中文封装

**模块信息**
- 模块文件名: 加密.js
- 路径: zh/后端/核心/加密.js
- 功能: 基于Node.js内置crypto库的中文API封装，提供加密、解密、哈希、HMAC、密钥管理、数字签名等功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持同步和异步操作，适应不同场景需求
- 提供简化的高级接口和完整的低级接口
- 内置安全的随机数生成、密码加密和验证功能
- 支持常见的加密算法、哈希算法和密钥交换

**命令总数：34个**

**随机数生成函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 生成随机字节 | 大小 = 32 | number | 生成指定大小的随机字节 | Buffer |
| 生成随机字符串 | 长度 = 32, 字符集 = '...' | number, string | 生成指定长度的随机字符串 | string |
| 生成UUID | 无 | 无 | 生成UUID v4 | string |
| 生成临时令牌 | 长度 = 32 | number | 生成临时令牌 | string |

**哈希函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建哈希 | 算法 = 'sha256' | string | 创建哈希对象 | Hash |
| 计算哈希 | 数据, 算法 = 'sha256', 输出编码 = 'hex' | string\|Buffer, string, string | 计算数据的哈希值 | string |
| 计算MD5 | 数据, 输出编码 = 'hex' | string\|Buffer, string | 计算MD5哈希 | string |
| 计算SHA1 | 数据, 输出编码 = 'hex' | string\|Buffer, string | 计算SHA1哈希 | string |
| 计算SHA256 | 数据, 输出编码 = 'hex' | string\|Buffer, string | 计算SHA256哈希 | string |
| 计算文件哈希 | 文件路径, 算法 = 'sha256' | string, string | 计算文件的哈希值 | Promise<string> |

**HMAC函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建HMAC | 算法 = 'sha256', 密钥 | string, string\|Buffer | 创建HMAC对象 | Hmac |
| 计算HMAC | 数据, 密钥, 算法 = 'sha256', 输出编码 = 'hex' | string\|Buffer, string\|Buffer, string, string | 计算HMAC值 | string |

**AES加密解密函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建AES加密器 | 密钥, 算法 = 'aes-256-cbc', 初始化向量 | string, string, Buffer\|string | 创建AES加密器 | Cipher |
| 创建AES解密器 | 密钥, 算法 = 'aes-256-cbc', 初始化向量 | string, string, Buffer\|string | 创建AES解密器 | Decipher |
| AES加密 | 数据, 密钥, 选项 = {} | string\|Buffer, string, Object | AES加密数据 | Object |
| AES解密 | 加密数据, 密钥, 初始化向量, 选项 = {} | string\|Buffer, string, string\|Buffer, Object | AES解密数据 | string |
| 加密字符串 | 明文, 密钥 | string, string | 简化的字符串加密 | string |
| 解密字符串 | 加密字符串, 密钥 | string, string | 简化的字符串解密 | string |

**密钥管理函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 生成密钥对 | 算法 = 'rsa', 选项 = {} | string, Object | 生成密钥对 | Promise<Object> |
| 派生密钥 | 密码, 选项 = {} | string, Object | 从密码派生密钥 | Buffer |
| 异步派生密钥 | 密码, 选项 = {} | string, Object | 异步从密码派生密钥 | Promise<Object> |
| 加密密码 | 密码, 选项 = {} | string, Object | 加密密码（带盐值） | string |
| 验证密码 | 密码, 哈希密码 | string, string | 验证密码是否匹配 | boolean |

**数字签名函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建数字签名 | 数据, 私钥, 选项 = {} | string\|Buffer, string\|Buffer, Object | 创建数字签名 | string |
| 验证数字签名 | 数据, 签名, 公钥, 选项 = {} | string\|Buffer, string, string\|Buffer, Object | 验证数字签名 | boolean |

**密钥交换函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建DiffieHellman | 模数长度 = 2048 | number | 创建DH密钥交换对象 | DiffieHellman |
| 创建DiffieHellmanWithParams | 质数, 生成器 = Buffer.from([2]) | Buffer, Buffer | 使用预定义参数创建DH对象 | DiffieHellman |
| 执行密钥交换 | 配置 = {} | Object | 执行DH密钥交换示例 | Object |

**工具函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 检查算法支持 | 算法, 类型 = 'digest' | string, string | 检查算法是否支持 | boolean |

**获取原始库** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始Crypto | 无 | 无 | 获取原始crypto库引用 | Object |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 加密 = require('./zh/后端/核心/加密.js');
```

**基本使用示例:**
```javascript
const 加密 = require('./zh/后端/核心/加密.js');

// 随机数生成
console.log('随机字节:', 加密.生成随机字节(16).toString('hex'));
console.log('随机字符串:', 加密.生成随机字符串(10));
console.log('UUID:', 加密.生成UUID());
console.log('临时令牌:', 加密.生成临时令牌());

// 哈希计算
const 数据 = '测试数据';
console.log('SHA256哈希:', 加密.计算SHA256(数据));
console.log('MD5哈希:', 加密.计算MD5(数据));

// HMAC计算
const 密钥 = 'secret-key';
console.log('HMAC:', 加密.计算HMAC(数据, 密钥));

// AES加密解密
const { 加密数据, 初始化向量 } = 加密.AES加密('敏感信息', 密钥);
console.log('AES加密结果:', 加密数据);
const 解密结果 = 加密.AES解密(加密数据, 密钥, 初始化向量);
console.log('AES解密结果:', 解密结果);

// 简化的字符串加密解密
const 加密文本 = 加密.加密字符串('简单加密', 'my-key');
console.log('简化加密:', 加密文本);
console.log('简化解密:', 加密.解密字符串(加密文本, 'my-key'));

// 密码加密和验证
const 哈希密码 = 加密.加密密码('user-password');
console.log('密码哈希:', 哈希密码);
console.log('密码验证正确:', 加密.验证密码('user-password', 哈希密码));
console.log('密码验证错误:', 加密.验证密码('wrong-password', 哈希密码));

// 数字签名示例（需要密钥对）
async function 签名示例() {
  try {
    // 生成密钥对
    const { 公钥, 私钥 } = await 加密.生成密钥对();
    
    // 创建签名
    const 消息 = '需要签名的消息';
    const 签名 = 加密.创建数字签名(消息, 私钥);
    console.log('签名:', 签名);
    
    // 验证签名
    const 验证结果 = 加密.验证数字签名(消息, 签名, 公钥);
    console.log('签名验证结果:', 验证结果);
  } catch (错误) {
    console.error('签名示例错误:', 错误);
  }
}

// 密钥交换示例
async function 密钥交换示例() {
  try {
    const 结果 = await 加密.执行密钥交换();
    console.log('密钥交换成功，密钥匹配:', 结果.共享密钥匹配);
  } catch (错误) {
    console.error('密钥交换错误:', 错误);
  }
}

// 计算文件哈希示例
async function 文件哈希示例() {
  try {
    const 文件路径 = 'example.txt';
    const 哈希值 = await 加密.计算文件哈希(文件路径);
    console.log(`文件${文件路径}的哈希值:`, 哈希值);
  } catch (错误) {
    console.error('文件哈希计算错误:', 错误);
  }
}

// 算法支持检查
console.log('支持SHA256:', 加密.检查算法支持('sha256'));
console.log('支持AES-256-CBC:', 加密.检查算法支持('aes-256-cbc', 'cipher'));

// 执行异步操作
signatureExample();
密钥交换示例();
文件哈希示例();
```

#### 进程与系统操作中文封装

**模块信息**
- 模块文件名: 进程与系统.js
- 路径: zh/后端/核心/进程与系统.js
- 功能: 基于Node.js内置process和os模块的中文API封装，提供进程管理、系统信息获取、环境变量操作等功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装进程管理相关功能
- 提供系统信息查询接口
- 支持环境变量操作
- 支持进程事件监听

**命令总数：26个**

**进程管理函数** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取当前工作目录 | 无 | 无 | 获取当前工作目录路径 | string |
| 更改工作目录 | 目录路径 | string | 更改当前工作目录 | undefined |
| 退出进程 | 退出码 = 0 | number | 退出进程 | undefined |
| 获取命令行参数 | 无 | 无 | 获取命令行参数数组 | string[] |
| 获取Node版本 | 无 | 无 | 获取Node.js版本号 | string |
| 获取平台 | 无 | 无 | 获取平台信息 | string |
| 获取架构 | 无 | 无 | 获取处理器架构 | string |
| 获取内存使用情况 | 无 | 无 | 获取内存使用情况对象 | Object |
| 杀死进程 | 进程ID, 信号 = 'SIGTERM' | number, string\|number | 杀死指定进程 | undefined |
| 监听进程事件 | 事件名, 回调函数 | string, Function | 添加进程事件监听器 | EventEmitter |

**系统信息函数** (12个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取CPU使用情况 | 无 | 无 | 获取CPU使用情况数组 | Object[] |
| 获取总内存 | 无 | 无 | 获取系统总内存（字节） | number |
| 获取空闲内存 | 无 | 无 | 获取系统空闲内存（字节） | number |
| 获取操作系统类型 | 无 | 无 | 获取操作系统类型 | string |
| 获取操作系统版本 | 无 | 无 | 获取操作系统版本 | string |
| 获取主机名 | 无 | 无 | 获取主机名 | string |
| 获取网络接口 | 无 | 无 | 获取网络接口信息对象 | Object |
| 获取临时目录 | 无 | 无 | 获取临时目录路径 | string |
| 获取用户信息 | 无 | 无 | 获取当前用户信息 | Object |
| 获取正常运行时间 | 无 | 无 | 获取系统正常运行时间（秒） | number |
| 获取CPU核心数 | 无 | 无 | 获取CPU核心数 | number |

**环境变量函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取环境变量 | 变量名 | string | 获取指定环境变量值 | string |
| 设置环境变量 | 变量名, 变量值 | string, string | 设置环境变量 | undefined |
| 获取所有环境变量 | 无 | 无 | 获取所有环境变量 | Object |

**事件处理函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 移除进程事件监听 | 事件名, 回调函数 | string, Function | 移除进程事件监听器 | EventEmitter |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 进程与系统 = require('./zh/后端/核心/进程与系统.js');
```

**基本使用示例:**
```javascript
const 进程与系统 = require('./zh/后端/核心/进程与系统.js');

// 进程管理相关操作
console.log('当前工作目录:', 进程与系统.获取当前工作目录());

// 注意：以下代码会实际更改工作目录，谨慎使用
// 进程与系统.更改工作目录('/path/to/new/directory');

console.log('命令行参数:', 进程与系统.获取命令行参数());
console.log('Node.js版本:', 进程与系统.获取Node版本());
console.log('平台:', 进程与系统.获取平台());
console.log('架构:', 进程与系统.获取架构());

// 内存使用情况
const 内存使用 = 进程与系统.获取内存使用情况();
console.log('内存使用情况:');
console.log('  堆总内存:', (内存使用.heapTotal / 1024 / 1024).toFixed(2), 'MB');
console.log('  堆使用内存:', (内存使用.heapUsed / 1024 / 1024).toFixed(2), 'MB');
console.log('  外部内存:', (内存使用.external / 1024 / 1024).toFixed(2), 'MB');

// 系统信息
console.log('CPU使用情况:', 进程与系统.获取CPU使用情况().length, '个核心');
console.log('系统总内存:', (进程与系统.获取总内存() / 1024 / 1024 / 1024).toFixed(2), 'GB');
console.log('系统空闲内存:', (进程与系统.获取空闲内存() / 1024 / 1024 / 1024).toFixed(2), 'GB');
console.log('操作系统类型:', 进程与系统.获取操作系统类型());
console.log('操作系统版本:', 进程与系统.获取操作系统版本());
console.log('主机名:', 进程与系统.获取主机名());
console.log('临时目录:', 进程与系统.获取临时目录());
console.log('系统运行时间:', (进程与系统.获取正常运行时间() / 3600).toFixed(2), '小时');

// 用户信息
const 用户信息 = 进程与系统.获取用户信息();
console.log('用户名:', 用户信息.username);
console.log('用户目录:', 用户信息.homedir);

// 网络接口信息
const 网络接口 = 进程与系统.获取网络接口();
console.log('网络接口数量:', Object.keys(网络接口).length);
// 打印第一个网络接口信息
const 接口名 = Object.keys(网络接口)[0];
if (接口名) {
  console.log(`${接口名}接口信息:`);
  网络接口[接口名].forEach(地址 => {
    if (!地址.internal) {
      console.log(`  IP地址: ${地址.address}`);
      console.log(`  MAC地址: ${地址.mac}`);
      console.log(`  网络掩码: ${地址.netmask}`);
    }
  });
}

// 环境变量操作
console.log('PATH环境变量:', 进程与系统.获取环境变量('PATH'));

// 设置临时环境变量（仅在当前进程有效）
进程与系统.设置环境变量('TEST_VAR', '测试值');
console.log('设置的环境变量:', 进程与系统.获取环境变量('TEST_VAR'));

// 获取所有环境变量（数量可能较多，建议筛选查看）
const 所有环境变量 = 进程与系统.获取所有环境变量();
console.log('环境变量数量:', Object.keys(所有环境变量).length);

// 进程事件监听示例
function 处理退出信号() {
  console.log('收到退出信号，正在清理...');
  // 执行清理工作
  console.log('清理完成，准备退出');
}

// 添加事件监听
进程与系统.监听进程事件('SIGINT', 处理退出信号);
进程与系统.监听进程事件('SIGTERM', 处理退出信号);

// 错误事件监听
进程与系统.监听进程事件('uncaughtException', (错误) => {
  console.error('未捕获的异常:', 错误);
  // 在实际应用中，可能需要记录日志并执行清理
});

// 注意：在实际应用中，可以在不再需要监听时移除事件监听
// 进程与系统.移除进程事件监听('SIGINT', 处理退出信号);

console.log('示例程序运行中... (按Ctrl+C测试退出信号)');

// 注意：以下代码会终止进程，谨慎使用
// setTimeout(() => {
//   console.log('程序将在5秒后退出');
//   setTimeout(() => {
//     进程与系统.退出进程(0);
//   }, 5000);
// }, 1000);
```

#### 流操作中文封装

**模块信息**
- 模块文件名: 流.js
- 路径: zh/后端/核心/流.js
- 功能: 基于Node.js内置stream和fs模块的中文API封装，提供流的创建、操作和管理功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装各类流的创建功能
- 支持流的管道连接和事件处理
- 提供流的读写控制功能
- 支持文件流式复制等实用操作

**命令总数：17个**

**流创建函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建可读流 | 路径, 选项 | string, Object | 创建文件可读流 | fs.ReadStream |
| 创建可写流 | 路径, 选项 | string, Object | 创建文件可写流 | fs.WriteStream |
| 创建转换流 | 选项 | Object | 创建转换流 | stream.Transform |
| 创建直通流 | 选项 | Object | 创建直通流 | stream.PassThrough |
| 创建双向流 | 选项 | Object | 创建双向流 | stream.Duplex |

**流操作函数** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 管道连接 | 可读流, 可写流 | stream.Readable, stream.Writable | 连接两个流 | stream.Writable |
| 解除管道连接 | 可读流, 可写流 | stream.Readable, stream.Writable | 解除流连接 | stream.Readable |
| 暂停流 | 可读流 | stream.Readable | 暂停可读流 | stream.Readable |
| 恢复流 | 可读流 | stream.Readable | 恢复可读流 | stream.Readable |
| 读取流数据 | 可读流, 大小 | stream.Readable, number | 从可读流读取数据 | Buffer\|null |
| 写入流数据 | 可写流, 数据, 编码, 回调函数 | stream.Writable, Buffer\|string, string, Function | 向可写流写入数据 | boolean |
| 结束可写流 | 可写流, 数据, 编码, 回调函数 | stream.Writable, Buffer\|string, string, Function | 结束可写流 | undefined |

**流控制函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是可读流 | 流对象 | stream.Stream | 检查是否可读 | boolean |
| 是可写流 | 流对象 | stream.Stream | 检查是否可写 | boolean |
| 关闭流 | 流对象, 回调函数 | stream.Stream, Function | 关闭流 | undefined |

**事件处理函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 监听流事件 | 流对象, 事件名, 回调函数 | stream.Stream, string, Function | 设置流事件监听 | undefined |

**文件操作函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 流式复制文件 | 源路径, 目标路径, 回调函数 | string, string, Function | 使用流复制文件 | undefined |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 流 = require('./zh/后端/核心/流.js');
```

**基本使用示例:**
```javascript
const 流 = require('./zh/后端/核心/流.js');
const path = require('path');

// 创建可读流示例
const 源文件路径 = path.join(__dirname, 'source.txt');
const 可读流实例 = 流.创建可读流(源文件路径, {
  highWaterMark: 64 * 1024, // 64KB 缓冲区
  encoding: 'utf8'
});

// 创建可写流示例
const 目标文件路径 = path.join(__dirname, 'destination.txt');
const 可写流实例 = 流.创建可写流(目标文件路径, {
  highWaterMark: 64 * 1024,
  encoding: 'utf8',
  flags: 'w'
});

// 监听可读流事件
流.监听流事件(可读流实例, 'data', (数据块) => {
  console.log('读取到数据:', 数据块.length, '字符');
  // 手动写入数据
  const 是否可继续写入 = 流.写入流数据(可写流实例, 数据块, 'utf8', (错误) => {
    if (错误) {
      console.error('写入错误:', 错误);
    }
  });
  
  // 如果返回false，表示缓冲区已满，需要暂停读取
  if (!是否可继续写入) {
    console.log('缓冲区已满，暂停读取');
    流.暂停流(可读流实例);
    
    // 等待drain事件后恢复读取
    流.监听流事件(可写流实例, 'drain', () => {
      console.log('缓冲区可用，恢复读取');
      流.恢复流(可读流实例);
    });
  }
});

流.监听流事件(可读流实例, 'end', () => {
  console.log('读取完成');
  // 结束可写流
  流.结束可写流(可写流实例, undefined, undefined, () => {
    console.log('写入完成');
  });
});

流.监听流事件(可读流实例, 'error', (错误) => {
  console.error('读取错误:', 错误);
  流.关闭流(可读流实例);
  流.关闭流(可写流实例);
});

流.监听流事件(可写流实例, 'error', (错误) => {
  console.error('写入错误:', 错误);
  流.关闭流(可读流实例);
  流.关闭流(可写流实例);
});

流.监听流事件(可写流实例, 'finish', () => {
  console.log('写入流已完成所有写入操作');
});

// 检查流类型
console.log('是可读流:', 流.是可读流(可读流实例));
console.log('是可写流:', 流.是可写流(可写流实例));

// 使用管道连接示例
console.log('\n使用管道连接复制文件:');
const 源文件 = path.join(__dirname, 'file1.txt');
const 目标文件 = path.join(__dirname, 'file2.txt');

流.流式复制文件(源文件, 目标文件, (错误) => {
  if (错误) {
    console.error('复制失败:', 错误);
  } else {
    console.log('文件复制成功');
  }
});

// 创建转换流示例
console.log('\n创建转换流示例:');
const 转换流实例 = 流.创建转换流({
  highWaterMark: 16,
  transform(chunk, encoding, callback) {
    // 将数据转换为大写
    const 转换后数据 = chunk.toString().toUpperCase();
    this.push(转换后数据);
    callback();
  }
});

// 创建测试用的可读流和可写流
const 测试可读流 = 流.创建可读流(源文件, { encoding: 'utf8' });
const 测试可写流 = 流.创建可写流(path.join(__dirname, 'transformed.txt'), { encoding: 'utf8' });

// 连接转换流
流.管道连接(测试可读流, 转换流实例);
流.管道连接(转换流实例, 测试可写流);

流.监听流事件(测试可写流, 'finish', () => {
  console.log('转换完成，结果已写入transformed.txt');
});
```
#### 路径操作中文封装

**模块信息**
- 模块文件名: 路径.js
- 路径: zh/后端/核心/路径.js
- 功能: 基于Node.js内置path模块的中文API封装，提供路径解析、连接、信息获取等功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装路径解析和转换功能
- 支持路径信息获取（文件名、目录名、扩展名等）
- 提供平台无关的路径操作
- 支持路径规范化和相对路径计算

**命令总数：13个**

**路径解析函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取绝对路径 | ...路径片段 | ...string | 获取路径的绝对路径 | string |
| 连接路径 | ...路径片段 | ...string | 连接多个路径片段 | string |
| 规范化路径 | 路径 | string | 规范化路径格式 | string |

**路径信息获取函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取目录名 | 路径 | string | 获取路径的目录名 | string |
| 获取文件名 | 路径, 扩展名 | string, string | 获取路径的文件名 | string |
| 获取扩展名 | 路径 | string | 获取路径的扩展名 | string |
| 解析路径 | 路径 | string | 解析路径为对象 | Object |
| 获取根目录 | 无 | 无 | 获取文件系统根目录 | string[] |

**路径转换函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 相对路径 | 从路径, 到路径 | string, string | 计算相对路径 | string |
| 格式化路径 | 路径对象 | Object | 从对象格式化路径 | string |

**路径判断函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是绝对路径 | 路径 | string | 判断是否为绝对路径 | boolean |

**系统分隔符函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取路径分隔符 | 无 | 无 | 获取平台路径分隔符 | string |
| 获取目录分隔符 | 无 | 无 | 获取平台目录分隔符 | string |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 路径 = require('./zh/后端/核心/路径.js');
```

**基本使用示例:**
```javascript
const 路径 = require('./zh/后端/核心/路径.js');

// 路径解析示例
console.log('当前绝对路径:', 路径.获取绝对路径('.'));
console.log('组合绝对路径:', 路径.获取绝对路径(__dirname, 'data', 'file.txt'));

// 路径连接示例
console.log('连接路径1:', 路径.连接路径('dir1', 'dir2', 'file.txt'));
console.log('连接路径2:', 路径.连接路径('dir1/', '/dir2', 'file.txt'));

// 路径规范化示例
console.log('规范化路径1:', 路径.规范化路径('dir1//dir2/../file.txt'));
console.log('规范化路径2:', 路径.规范化路径('dir1/./dir2/file.txt'));

// 路径信息获取示例
const 测试路径 = '/home/user/docs/report.pdf';
console.log('目录名:', 路径.获取目录名(测试路径));
console.log('文件名:', 路径.获取文件名(测试路径));
console.log('文件名(不含扩展名):', 路径.获取文件名(测试路径, '.pdf'));
console.log('扩展名:', 路径.获取扩展名(测试路径));

// 路径解析为对象
const 路径对象 = 路径.解析路径(测试路径);
console.log('路径对象:', 路径对象);
console.log('路径对象的根目录:', 路径对象.root);
console.log('路径对象的目录:', 路径对象.dir);
console.log('路径对象的基本名:', 路径对象.base);
console.log('路径对象的扩展名:', 路径对象.ext);
console.log('路径对象的名称:', 路径对象.name);

// 从对象格式化路径
const 新路径对象 = {
  root: '/',
  dir: '/home/user/projects',
  base: 'script.js',
  ext: '.js',
  name: 'script'
};
console.log('格式化路径:', 路径.格式化路径(新路径对象));

// 相对路径计算
const 起始路径 = '/home/user/docs';
const 目标路径 = '/home/user/projects/app';
console.log('相对路径:', 路径.相对路径(起始路径, 目标路径));

// 绝对路径判断
console.log('是绝对路径? /home/user:', 路径.是绝对路径('/home/user'));
console.log('是绝对路径? user/docs:', 路径.是绝对路径('user/docs'));

// 系统分隔符获取
console.log('路径分隔符:', JSON.stringify(路径.获取路径分隔符()));
console.log('目录分隔符:', JSON.stringify(路径.获取目录分隔符()));

// 实际应用示例：构建文件路径
function 构建文件路径(基础目录, 子目录, 文件名) {
  return 路径.连接路径(基础目录, 子目录, 文件名);
}

const 数据目录 = 'data';
const 用户目录 = 'users';
const 文件名 = 'profile.json';

console.log('构建的文件路径:', 构建文件路径(数据目录, 用户目录, 文件名));

// 示例：检查文件扩展名
function 检查文件类型(文件路径, 目标扩展名) {
  const 当前扩展名 = 路径.获取扩展名(文件路径).toLowerCase();
  return 当前扩展名 === 目标扩展名.toLowerCase();
}

const 上传文件 = 'document.pdf';
console.log('是PDF文件?', 检查文件类型(上传文件, '.pdf'));
console.log('是PNG文件?', 检查文件类型(上传文件, '.png'));

// 示例：规范化用户输入的路径
function 安全路径(用户输入路径) {
  // 先规范化路径
  const 规范路径 = 路径.规范化路径(用户输入路径);
  
  // 检查是否包含路径遍历尝试
  if (规范路径.includes('..')) {
    console.warn('警告: 路径包含父目录引用');
  }
  
  return 规范路径;
}

console.log('安全处理后的路径:', 安全路径('../secret/file.txt'));
```
#### 实用工具操作中文封装

**模块信息**
- 模块文件名: 实用工具.js
- 路径: zh/后端/核心/实用工具.js
- 功能: 基于Node.js内置util、querystring和url模块的中文API封装，提供工具函数、类型检查、URL处理等功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装Node.js实用工具函数
- 支持类型检查和判断功能
- 提供URL和查询字符串处理
- 包含对象操作和异步控制工具

**命令总数：19个**

**工具函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 格式化字符串 | 格式字符串, ...参数 | string, ...* | 格式化字符串，替换占位符 | string |
| 是类型 | 值, 类型 | *, Function/string | 检查值是否为指定类型 | boolean |
| 转换为Promise | 函数 | Function | 将回调函数转换为Promise | Function |
| 转换为回调 | 函数 | Function | 将Promise函数转换为回调函数 | Function |
| 创建继承 | 子类, 父类 | Function, Function | 创建类继承关系 | void |
| 检查对象 | 对象, 选项 | *, Object | 获取对象的检查表示 | string |

**类型检查函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 是数组 | 值 | * | 检查值是否为数组 | boolean |
| 是对象 | 值 | * | 检查值是否为对象（非null） | boolean |
| 是函数 | 值 | * | 检查值是否为函数 | boolean |
| 是字符串 | 值 | * | 检查值是否为字符串 | boolean |
| 是数字 | 值 | * | 检查值是否为有效数字 | boolean |
| 是布尔值 | 值 | * | 检查值是否为布尔值 | boolean |

**URL处理函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 解析URL | url字符串, 解析查询字符串 | string, boolean | 解析URL字符串 | Object |
| 格式化URL | url对象 | Object | 格式化URL对象为字符串 | string |
| 解析查询字符串 | 查询字符串 | string | 解析URL查询字符串部分 | Object |
| 对象转查询字符串 | 对象 | Object | 将对象转换为查询字符串 | string |

**对象操作函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 深度复制 | 对象 | Object | 深度复制对象 | Object |

**异步控制函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 延迟 | 毫秒 | number | 延迟执行，返回Promise | Promise |
| 重试 | 函数, 最大尝试次数, 延迟毫秒 | Function, number, number | 重试函数执行 | Promise |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 实用工具 = require('./zh/后端/核心/实用工具.js');
```

**基本使用示例:**
```javascript
const 实用工具 = require('./zh/后端/核心/实用工具.js');

// 工具函数示例
console.log('格式化字符串:', 实用工具.格式化字符串('Hello, %s!', 'World'));
console.log('格式化多个参数:', 实用工具.格式化字符串('%d + %d = %d', 1, 2, 3));

// 类型检查示例
const 测试数组 = [1, 2, 3];
const 测试对象 = { name: '测试' };
const 测试函数 = () => {};
const 测试字符串 = 'Hello';
const 测试数字 = 42;
const 测试布尔 = true;
const 测试空 = null;
const 测试未定义 = undefined;

console.log('是数组?', 实用工具.是数组(测试数组));
console.log('是对象?', 实用工具.是对象(测试对象), 'null是对象?', 实用工具.是对象(测试空));
console.log('是函数?', 实用工具.是函数(测试函数));
console.log('是字符串?', 实用工具.是字符串(测试字符串));
console.log('是数字?', 实用工具.是数字(测试数字), 'NaN是数字?', 实用工具.是数字(NaN));
console.log('是布尔值?', 实用工具.是布尔值(测试布尔));

// URL处理示例
const 测试URL = 'https://example.com/path?query=value&num=123';
const 解析结果 = 实用工具.解析URL(测试URL, true);
console.log('解析URL结果:', 解析结果);
console.log('协议:', 解析结果.protocol);
console.log('主机名:', 解析结果.hostname);
console.log('路径名:', 解析结果.pathname);
console.log('查询参数:', 解析结果.query);

const URL对象 = {
  protocol: 'https:',
  hostname: 'test.com',
  pathname: '/api/data',
  query: { id: '123', type: 'test' }
};
console.log('格式化URL对象:', 实用工具.格式化URL(URL对象));

// 查询字符串处理示例
const 查询字符串 = 'name=张三&age=25&city=北京';
const 解析查询 = 实用工具.解析查询字符串(查询字符串);
console.log('解析查询字符串:', 解析查询);

const 数据对象 = { user: 'admin', role: 'manager', active: true };
const 生成查询字符串 = 实用工具.对象转查询字符串(数据对象);
console.log('对象转查询字符串:', 生成查询字符串);

// 对象操作示例
const 原始对象 = {
  id: 1,
  name: '原始对象',
  details: {
    created: new Date(),
    tags: ['重要', '更新']
  },
  isActive: true
};

const 复制对象 = 实用工具.深度复制(原始对象);
原始对象.details.tags.push('修改'); // 修改原始对象
console.log('原始对象标签:', 原始对象.details.tags);
console.log('复制对象标签:', 复制对象.details.tags); // 不会受到影响

// Promise转换示例
const fs = require('fs');
const 读取文件Promise = 实用工具.转换为Promise(fs.readFile);

// 异步控制示例
async function 异步示例() {
  console.log('开始异步操作');
  await 实用工具.延迟(1000);
  console.log('延迟1秒后');
  
  // 重试示例 - 模拟可能失败的操作
  let 尝试计数器 = 0;
  const 可能失败的函数 = async () => {
    尝试计数器++;
    console.log(`尝试第 ${尝试计数器} 次`);
    
    if (尝试计数器 < 3) {
      throw new Error('模拟失败');
    }
    return '操作成功！';
  };
  
  try {
    const 结果 = await 实用工具.重试(可能失败的函数, 5, 500);
    console.log('重试结果:', 结果);
  } catch (错误) {
    console.error('达到最大重试次数:', 错误.message);
  }
}

// 执行异步示例
异步示例().catch(console.error);

// 实际应用示例：API响应处理
function 处理API响应(数据, 状态码 = 200) {
  // 验证数据类型
  if (!实用工具.是对象(数据)) {
    throw new Error('响应数据必须是对象');
  }
  
  // 检查必要字段
  if (!数据.message) {
    data.message = 状态码 >= 400 ? '操作失败' : '操作成功';
  }
  
  return {
    code: 状态码,
    message: 数据.message,
    data: 数据.data || null,
    timestamp: Date.now()
  };
}

const API数据 = { message: '用户信息获取成功', data: { id: 1, name: '张三' } };
console.log('处理后的API响应:', 处理API响应(API数据));

// 示例：安全地访问对象属性
function 安全获取属性(对象, ...属性路径) {
  if (!实用工具.是对象(对象)) {
    return undefined;
  }
  
  let 当前值 = 对象;
  for (const 属性 of 属性路径) {
    if (当前值 === null || 当前值 === undefined) {
      return undefined;
    }
    当前值 = 当前值[属性];
  }
  return 当前值;
}

const 用户数据 = {
  profile: {
    name: '李四',
    contact: {
      email: 'lisi@example.com',
      phone: '13800138000'
    }
  }
};

console.log('用户邮箱:', 安全获取属性(用户数据, 'profile', 'contact', 'email'));
console.log('不存在的属性:', 安全获取属性(用户数据, 'settings', 'theme')); // 不会抛出错误
```

#### 事件操作中文封装

**模块信息**
- 模块文件名: 事件.js
- 路径: zh/后端/核心/事件.js
- 功能: 基于Node.js内置events模块的中文API封装，提供事件监听、触发和管理功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装Node.js事件处理功能
- 支持事件监听器的添加、移除和管理
- 提供事件触发和查询功能
- 包含预配置的事件发射器类可直接继承使用

**命令总数：13个**

**事件监听器管理** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建事件发射器 | 无 | 无 | 创建新的事件发射器实例 | EventEmitter |
| 添加事件监听 | 事件发射器, 事件名, 监听器 | EventEmitter, string/symbol, Function | 添加事件监听器 | EventEmitter |
| 添加一次性事件监听 | 事件发射器, 事件名, 监听器 | EventEmitter, string/symbol, Function | 添加只触发一次的监听器 | EventEmitter |
| 移除事件监听 | 事件发射器, 事件名, 监听器 | EventEmitter, string/symbol, Function | 移除指定监听器 | EventEmitter |
| 移除所有事件监听 | 事件发射器, 事件名 | EventEmitter, string/symbol(可选) | 移除所有或指定事件的监听器 | EventEmitter |
| 事件发射器类 | 无 | 无 | 预配置的事件发射器类 | Class |

**事件触发与查询** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 触发事件 | 事件发射器, 事件名, ...参数 | EventEmitter, string/symbol, ...* | 触发指定事件 | boolean |
| 获取事件监听器 | 事件发射器, 事件名 | EventEmitter, string/symbol | 获取指定事件的监听器数组 | Function[] |
| 获取原始事件监听器 | 事件发射器, 事件名 | EventEmitter, string/symbol | 获取所有监听器(包括封装的) | Function[] |
| 获取事件名称 | 事件发射器 | EventEmitter | 获取所有已注册的事件名称 | (string/symbol)[] |

**配置与管理** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置最大监听器数量 | 事件发射器, 数量 | EventEmitter, number | 设置单个事件的最大监听器数 | EventEmitter |
| 获取最大监听器数量 | 事件发射器 | EventEmitter | 获取当前最大监听器数量 | number |
| 获取监听器数量 | 事件发射器, 事件名 | EventEmitter, string/symbol | 获取指定事件的监听器数量 | number |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 事件 = require('./zh/后端/核心/事件.js');
```

**基本使用示例:**
```javascript
const 事件 = require('./zh/后端/核心/事件.js');

// 创建事件发射器实例
const 发射器 = 事件.创建事件发射器();

// 添加事件监听器示例
const 消息处理函数 = (消息) => {
  console.log('收到消息:', 消息);
};

事件.添加事件监听(发射器, '消息', 消息处理函数);

// 添加多个监听器
事件.添加事件监听(发射器, '消息', (消息) => {
  console.log('另一个消息处理器:', 消息);
});

// 添加一次性事件监听
事件.添加一次性事件监听(发射器, '一次性', (数据) => {
  console.log('一次性事件被触发:', 数据);
  // 这个监听器只会执行一次
});

// 触发事件示例
console.log('触发消息事件结果:', 事件.触发事件(发射器, '消息', '你好，世界！'));
console.log('触发不存在事件结果:', 事件.触发事件(发射器, '不存在的事件', '测试'));

// 触发一次性事件两次，但只会执行一次
事件.触发事件(发射器, '一次性', '第一次');
事件.触发事件(发射器, '一次性', '第二次'); // 不会有输出

// 获取事件监听器信息
const 监听器数组 = 事件.获取事件监听器(发射器, '消息');
console.log('消息事件的监听器数量:', 监听器数组.length);

// 获取原始事件监听器
const 原始监听器 = 事件.获取原始事件监听器(发射器, '消息');
console.log('原始监听器数量:', 原始监听器.length);

// 获取所有事件名称
const 事件名称列表 = 事件.获取事件名称(发射器);
console.log('已注册的事件:', 事件名称列表);

// 获取指定事件的监听器数量
const 监听器数量 = 事件.获取监听器数量(发射器, '消息');
console.log('消息事件的监听器数量:', 监听器数量);

// 移除特定监听器
事件.移除事件监听(发射器, '消息', 消息处理函数);
console.log('移除一个监听器后，消息事件的监听器数量:', 事件.获取监听器数量(发射器, '消息'));

// 移除所有监听器
事件.移除所有事件监听(发射器, '消息');
console.log('移除所有监听器后，消息事件的监听器数量:', 事件.获取监听器数量(发射器, '消息'));

// 设置和获取最大监听器数量
const 默认最大值 = 事件.获取最大监听器数量(发射器);
console.log('默认最大监听器数量:', 默认最大值);

事件.设置最大监听器数量(发射器, 20);
console.log('新的最大监听器数量:', 事件.获取最大监听器数量(发射器));

// 实际应用示例：实现发布-订阅模式
class 事件总线 {
  constructor() {
    this.发射器 = 事件.创建事件发射器();
  }
  
  订阅(事件名, 处理函数) {
    return 事件.添加事件监听(this.发射器, 事件名, 处理函数);
  }
  
  发布(事件名, ...数据) {
    return 事件.触发事件(this.发射器, 事件名, ...数据);
  }
  
  取消订阅(事件名, 处理函数) {
    return 事件.移除事件监听(this.发射器, 事件名, 处理函数);
  }
}

// 使用事件总线
const 总线 = new 事件总线();

const 用户注册处理 = (用户信息) => {
  console.log('用户注册成功:', 用户信息.username);
};

const 发送欢迎邮件 = (用户信息) => {
  console.log('向', 用户信息.email, '发送欢迎邮件');
};

// 订阅事件
总线.订阅('用户注册', 用户注册处理);
总线.订阅('用户注册', 发送欢迎邮件);

// 发布事件
总线.发布('用户注册', { username: 'zhangsan', email: 'zhangsan@example.com' });

// 取消订阅
总线.取消订阅('用户注册', 发送欢迎邮件);
总线.发布('用户注册', { username: 'lisi', email: 'lisi@example.com' }); // 只会触发用户注册处理

// 示例：使用事件发射器类创建自定义类
class 文件读取器 extends 事件.事件发射器类 {
  constructor() {
    super();
    // 自定义初始化
  }
  
  模拟读取文件(文件路径) {
    // 模拟异步文件读取
    setTimeout(() => {
      this.emit('读取开始', 文件路径);
      
      // 模拟读取过程
      setTimeout(() => {
        this.emit('读取进度', { path: 文件路径, progress: 50 });
        
        // 模拟完成读取
        setTimeout(() => {
          this.emit('读取完成', { path: 文件路径, data: '文件内容' });
        }, 300);
      }, 300);
    }, 200);
  }
}

// 使用自定义事件类
const 读取器 = new 文件读取器();

读取器.on('读取开始', (路径) => {
  console.log('开始读取文件:', 路径);
});

读取器.on('读取进度', (进度信息) => {
  console.log(`读取进度: ${进度信息.progress}%`);
});

读取器.on('读取完成', (结果) => {
  console.log('读取完成:', 结果);
});

读取器.模拟读取文件('/path/to/file.txt');

// 示例：处理错误事件
const 错误发射器 = 事件.创建事件发射器();

// 添加错误处理监听器
事件.添加事件监听(错误发射器, 'error', (错误) => {
  console.error('捕获到错误:', 错误.message);
});

// 触发错误事件（不会导致程序崩溃）
事件.触发事件(错误发射器, 'error', new Error('测试错误处理'));

// 不添加错误监听器的情况会导致程序崩溃（此处仅作注释，不实际执行）
// const 无错误处理发射器 = 事件.创建事件发射器();
// 事件.触发事件(无错误处理发射器, 'error', new Error('未捕获的错误'));
```
#### 文件系统操作中文封装

**模块信息**
- 模块文件名: 文件系统.js
- 路径: zh/后端/核心/文件系统.js
- 功能: 基于Node.js内置fs和path模块的中文API封装，提供文件和目录操作功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装Node.js文件系统操作功能
- 同时支持异步和同步操作方法
- 包含文件读写、目录管理、路径操作等核心功能
- 提供直观易用的文件系统接口

**命令总数：31个**

**文件读写操作** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 读取文件 | 文件路径, 选项, 回调函数 | string, Object/string, Function | 异步读取文件内容 | undefined |
| 读取文件同步 | 文件路径, 选项 | string, Object/string | 同步读取文件内容 | Buffer/string |
| 写入文件 | 文件路径, 数据, 选项, 回调函数 | string, string/Buffer, Object/string, Function | 异步写入文件内容 | undefined |
| 写入文件同步 | 文件路径, 数据, 选项 | string, string/Buffer, Object/string | 同步写入文件内容 | undefined |
| 追加文件 | 文件路径, 数据, 选项, 回调函数 | string, string/Buffer, Object/string, Function | 异步追加内容到文件 | undefined |
| 追加文件同步 | 文件路径, 数据, 选项 | string, string/Buffer, Object/string | 同步追加内容到文件 | undefined |
| 复制文件 | 源路径, 目标路径, 选项, 回调函数 | string, string, Object, Function | 异步复制文件 | undefined |
| 复制文件同步 | 源路径, 目标路径, 选项 | string, string, Object | 同步复制文件 | undefined |
| 重命名 | 旧路径, 新路径, 回调函数 | string, string, Function | 异步重命名文件或目录 | undefined |
| 重命名同步 | 旧路径, 新路径 | string, string | 同步重命名文件或目录 | undefined |

**目录操作** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 读取目录 | 目录路径, 选项, 回调函数 | string, Object/string, Function | 异步读取目录内容 | undefined |
| 读取目录同步 | 目录路径, 选项 | string, Object/string | 同步读取目录内容 | string[]/Buffer[] |
| 创建目录 | 目录路径, 选项, 回调函数 | string, Object, Function | 异步创建目录 | undefined |
| 创建目录同步 | 目录路径, 选项 | string, Object | 同步创建目录 | undefined |
| 删除目录 | 目录路径, 回调函数 | string, Function | 异步删除目录 | undefined |
| 删除目录同步 | 目录路径 | string | 同步删除目录 | undefined |
| 删除文件 | 文件路径, 回调函数 | string, Function | 异步删除文件 | undefined |
| 删除文件同步 | 文件路径 | string | 同步删除文件 | undefined |
| 删除路径 | 路径, 选项, 回调函数 | string, Object, Function | 异步删除文件或目录（支持递归删除） | undefined |
| 删除路径同步 | 路径, 选项 | string, Object | 同步删除文件或目录（支持递归删除） | undefined |

**文件信息与检查** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取文件信息 | 路径, 回调函数 | string, Function | 异步获取文件或目录信息 | undefined |
| 获取文件信息同步 | 路径 | string | 同步获取文件或目录信息 | Object |
| 路径是否存在 | 路径, 回调函数 | string, Function | 异步检查路径是否存在 | undefined |
| 路径是否存在同步 | 路径 | string | 同步检查路径是否存在 | boolean |

**路径处理** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取绝对路径 | 路径 | string | 获取路径的绝对路径 | string |
| 连接路径 | ...路径片段 | ...string | 连接路径片段 | string |
| 获取目录名 | 路径 | string | 获取路径的目录名 | string |
| 获取文件名 | 路径, 包含扩展名 | string, boolean | 获取路径的文件名 | string |
| 获取扩展名 | 路径 | string | 获取路径的扩展名 | string |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const 文件系统 = require('./zh/后端/核心/文件系统.js');
```

**基本使用示例:**
```javascript
const 文件系统 = require('./zh/后端/核心/文件系统.js');

// 异步读取文件示例
文件系统.读取文件('example.txt', 'utf8', (错误, 数据) => {
  if (错误) {
    console.error('读取文件失败:', 错误);
    return;
  }
  console.log('文件内容:', 数据);
});

// 同步读取文件示例
try {
  const 内容 = 文件系统.读取文件同步('example.txt', 'utf8');
  console.log('文件内容:', 内容);
} catch (错误) {
  console.error('读取文件失败:', 错误);
}

// 异步写入文件示例
文件系统.写入文件('output.txt', '这是新内容', 'utf8', (错误) => {
  if (错误) {
    console.error('写入文件失败:', 错误);
    return;
  }
  console.log('文件写入成功');
});

// 异步创建目录示例
文件系统.创建目录('新目录', { recursive: true }, (错误) => {
  if (错误) {
    console.error('创建目录失败:', 错误);
    return;
  }
  console.log('目录创建成功');
});

// 获取文件信息示例
文件系统.获取文件信息('example.txt', (错误, 统计信息) => {
  if (错误) {
    console.error('获取文件信息失败:', 错误);
    return;
  }
  console.log('是否为文件:', 统计信息.isFile());
  console.log('是否为目录:', 统计信息.isDirectory());
  console.log('文件大小:', 统计信息.size);
  console.log('修改时间:', 统计信息.mtime);
});

// 路径处理示例
const 绝对路径 = 文件系统.获取绝对路径('./example.txt');
console.log('绝对路径:', 绝对路径);

const 合并路径 = 文件系统.连接路径('目录1', '目录2', '文件.txt');
console.log('合并路径:', 合并路径);

const 目录名 = 文件系统.获取目录名('/path/to/file.txt');
console.log('目录名:', 目录名);

const 文件名 = 文件系统.获取文件名('/path/to/file.txt');
console.log('文件名(带扩展名):', 文件名);

const 文件名不带扩展名 = 文件系统.获取文件名('/path/to/file.txt', false);
console.log('文件名(不带扩展名):', 文件名不带扩展名);

const 扩展名 = 文件系统.获取扩展名('/path/to/file.txt');
console.log('扩展名:', 扩展名);

// 检查文件是否存在
if (文件系统.路径是否存在同步('example.txt')) {
  console.log('文件存在');
} else {
  console.log('文件不存在');
}

// 复制文件示例
文件系统.复制文件('source.txt', 'destination.txt', (错误) => {
  if (错误) {
    console.error('复制文件失败:', 错误);
    return;
  }
  console.log('文件复制成功');
});

// 重命名文件示例
文件系统.重命名('oldname.txt', 'newname.txt', (错误) => {
  if (错误) {
    console.error('重命名文件失败:', 错误);
    return;
  }
  console.log('文件重命名成功');
});

// 删除文件示例
文件系统.删除文件('todelete.txt', (错误) => {
  if (错误) {
    console.error('删除文件失败:', 错误);
    return;
  }
  console.log('文件删除成功');
});

// 递归删除目录示例
文件系统.删除路径('目录要删除', { recursive: true }, (错误) => {
  if (错误) {
    console.error('删除目录失败:', 错误);
    return;
  }
  console.log('目录删除成功');
});

// 实用文件操作函数示例
function 读取JSON文件(文件路径) {
  try {
    const 内容 = 文件系统.读取文件同步(文件路径, 'utf8');
    return JSON.parse(内容);
  } catch (错误) {
    console.error('读取JSON文件失败:', 错误);
    return null;
  }
}

function 写入JSON文件(文件路径, 数据) {
  try {
    const JSON内容 = JSON.stringify(数据, null, 2);
    文件系统.写入文件同步(文件路径, JSON内容, 'utf8');
    return true;
  } catch (错误) {
    console.error('写入JSON文件失败:', 错误);
    return false;
  }
}

// 使用自定义函数
const 配置 = 读取JSON文件('config.json');
if (配置) {
  console.log('读取的配置:', 配置);
}

const 新配置 = { name: 'test', version: '1.0.0' };
if (写入JSON文件('newconfig.json', 新配置)) {
  console.log('配置写入成功');
}

// 创建目录树示例
function 创建目录树(目录路径) {
  try {
    文件系统.创建目录同步(目录路径, { recursive: true });
    console.log(`目录树 ${目录路径} 创建成功`);
  } catch (错误) {
    console.error('创建目录树失败:', 错误);
  }
}

// 创建多级目录
创建目录树('project/src/components');
```

#### HTTP操作中文封装

**模块信息**
- 模块文件名: HTTP.js
- 路径: zh/后端/核心/HTTP.js
- 功能: 基于Node.js内置http和https模块的中文API封装，提供HTTP/HTTPS服务器创建和请求发送功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装Node.js HTTP/HTTPS功能
- 支持HTTP和HTTPS服务器创建与管理
- 提供客户端请求发送能力
- 包含请求处理和响应生成的完整功能集

**命令总数：16个**

**服务器创建与管理** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建HTTP服务器 | 请求处理函数 | Function | 创建HTTP服务器实例 | http.Server |
| 创建HTTPS服务器 | 选项, 请求处理函数 | Object, Function | 创建HTTPS服务器实例 | https.Server |
| 监听端口 | 服务器, 端口, 主机名, 回调函数 | Server, number, string, Function | 让服务器监听指定端口 | Server |
| 关闭服务器 | 服务器, 回调函数 | Server, Function | 停止服务器监听 | Server |

**客户端请求** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 发送HTTP请求 | 选项, 回调函数 | Object/string, Function | 发送HTTP请求 | http.ClientRequest |
| 发送HTTPS请求 | 选项, 回调函数 | Object/string, Function | 发送HTTPS请求 | https.ClientRequest |
| 发送GET请求 | 选项, 回调函数 | Object/string, Function | 发送HTTP GET请求 | http.ClientRequest |
| 发送HTTPSGET请求 | 选项, 回调函数 | Object/string, Function | 发送HTTPS GET请求 | https.ClientRequest |
| 获取查询参数 | 请求对象 | http.IncomingMessage | 从请求中获取URL查询参数 | Object |
| 获取请求URL | 请求对象 | http.IncomingMessage | 获取请求URL | string |

**请求处理** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取请求方法 | 请求对象 | http.IncomingMessage | 获取HTTP请求方法 | string |
| 获取请求头 | 请求对象, 头名称 | http.IncomingMessage, string(可选) | 获取请求头信息 | Object/string |

**响应生成** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置响应头 | 响应对象, 头名称, 头值 | http.ServerResponse, string, string | 设置HTTP响应头 | undefined |
| 写入状态码 | 响应对象, 状态码, 状态消息 | http.ServerResponse, number, string(可选) | 写入HTTP状态码 | undefined |
| 写入响应数据 | 响应对象, 数据, 选项 | http.ServerResponse, string/Buffer, Object(可选) | 向HTTP响应写入数据 | boolean |
| 结束响应 | 响应对象, 数据, 选项 | http.ServerResponse, string/Buffer(可选), Object(可选) | 结束HTTP响应 | undefined |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个模块
const HTTP = require('./zh/后端/核心/HTTP.js');
```

**基本使用示例:**
```javascript
const HTTP = require('./zh/后端/核心/HTTP.js');

// 创建简单的HTTP服务器示例
const 服务器 = HTTP.创建HTTP服务器((请求, 响应) => {
  // 获取请求信息
  const 请求方法 = HTTP.获取请求方法(请求);
  const 请求URL = HTTP.获取请求URL(请求);
  const 查询参数 = HTTP.获取查询参数(请求);
  const 请求头 = HTTP.获取请求头(请求);
  
  console.log(`收到${请求方法}请求: ${请求URL}`);
  console.log('查询参数:', 查询参数);
  
  // 设置响应头
  HTTP.设置响应头(响应, 'Content-Type', 'text/plain; charset=utf-8');
  
  // 写入状态码
  HTTP.写入状态码(响应, 200, 'OK');
  
  // 写入响应数据
  HTTP.写入响应数据(响应, '你好，这是HTTP服务器响应\n');
  HTTP.写入响应数据(响应, `请求方法: ${请求方法}\n`);
  HTTP.写入响应数据(响应, `请求路径: ${请求URL}\n`);
  
  // 结束响应
  HTTP.结束响应(响应);
});

// 监听端口
HTTP.监听端口(服务器, 3000, 'localhost', () => {
  console.log('服务器运行在 http://localhost:3000/');
});

// 发送GET请求示例
function 发送请求示例() {
  console.log('发送GET请求到 http://example.com');
  
  const 请求 = HTTP.发送GET请求('http://example.com', (响应) => {
    console.log(`状态码: ${响应.statusCode}`);
    console.log('响应头:', HTTP.获取请求头(响应));
    
    let 数据 = '';
    response.on('data', (块) => {
      数据 += 块;
    });
    
    response.on('end', () => {
      console.log('响应数据长度:', 数据.length, '字节');
    });
  });
  
  请求.on('error', (错误) => {
    console.error('请求错误:', 错误.message);
  });
  
  请求.end();
}

// 发送带选项的POST请求示例
function 发送POST请求示例() {
  const 选项 = {
    hostname: 'httpbin.org',
    port: 80,
    path: '/post',
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': JSON.stringify({name: '测试', value: 123}).length
    }
  };
  
  const 请求 = HTTP.发送HTTP请求(选项, (响应) => {
    let 数据 = '';
    
    response.on('data', (块) => {
      数据 += 块;
    });
    
    response.on('end', () => {
      console.log('POST请求响应:', JSON.parse(数据));
    });
  });
  
  // 写入请求数据
  请求.write(JSON.stringify({name: '测试', value: 123}));
  请求.end();
}

// 创建REST API服务器示例
function 创建REST服务器() {
  // 模拟数据
  let 用户列表 = [
    { id: 1, name: '张三', age: 25 },
    { id: 2, name: '李四', age: 30 }
  ];
  
  const API服务器 = HTTP.创建HTTP服务器((请求, 响应) => {
    const URL = HTTP.获取请求URL(请求);
    const 方法 = HTTP.获取请求方法(请求);
    
    // 设置CORS头
    HTTP.设置响应头(响应, 'Access-Control-Allow-Origin', '*');
    HTTP.设置响应头(响应, 'Content-Type', 'application/json; charset=utf-8');
    
    // 处理不同的API端点
    if (URL === '/api/users' && 方法 === 'GET') {
      // 获取用户列表
      HTTP.写入状态码(响应, 200);
      HTTP.结束响应(响应, JSON.stringify(用户列表));
    } 
    else if (URL.startsWith('/api/users/') && 方法 === 'GET') {
      // 获取单个用户
      const id = parseInt(URL.split('/')[3]);
      const 用户 = 用户列表.find(u => u.id === id);
      
      if (用户) {
        HTTP.写入状态码(响应, 200);
        HTTP.结束响应(响应, JSON.stringify(用户));
      } else {
        HTTP.写入状态码(响应, 404);
        HTTP.结束响应(响应, JSON.stringify({ error: '用户不存在' }));
      }
    }
    else {
      HTTP.写入状态码(响应, 404);
      HTTP.结束响应(响应, JSON.stringify({ error: '端点不存在' }));
    }
  });
  
  HTTP.监听端口(API服务器, 3001, () => {
    console.log('REST API服务器运行在 http://localhost:3001/');
  });
}

// 错误处理示例
function 错误处理服务器() {
  const 错误服务器 = HTTP.创建HTTP服务器((请求, 响应) => {
    try {
      const URL = HTTP.获取请求URL(请求);
      
      if (URL === '/error') {
        // 模拟错误
        throw new Error('这是一个测试错误');
      }
      
      HTTP.写入状态码(响应, 200);
      HTTP.结束响应(响应, '正常响应');
    } catch (错误) {
      // 错误处理
      console.error('服务器错误:', 错误);
      HTTP.写入状态码(响应, 500);
      HTTP.结束响应(响应, `服务器错误: ${错误.message}`);
    }
  });
  
  // 监听服务器错误
  错误服务器.on('error', (错误) => {
    console.error('服务器异常:', 错误);
  });
  
  HTTP.监听端口(错误服务器, 3002, () => {
    console.log('错误处理服务器运行在 http://localhost:3002/');
  });
}

// 启动各种示例服务器
// 创建REST服务器();
// 错误处理服务器();
// 发送请求示例();
// 发送POST请求示例();

// 优雅关闭服务器示例
function 优雅关闭示例() {
  const 服务器 = HTTP.创建HTTP服务器((请求, 响应) => {
    HTTP.设置响应头(响应, 'Content-Type', 'text/plain');
    HTTP.结束响应(响应, 'Hello World\n');
  });
  
  const 服务器实例 = HTTP.监听端口(服务器, 3003, () => {
    console.log('服务器运行在 http://localhost:3003/');
    
    // 3秒后关闭服务器
    setTimeout(() => {
      console.log('正在关闭服务器...');
      HTTP.关闭服务器(服务器, () => {
        console.log('服务器已关闭');
      });
    }, 3000);
  });
}
```

#### 令牌操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/令牌/index.js
- 功能: 基于jsonwebtoken库的中文API封装，提供JWT令牌的生成、验证、刷新等完整功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 全面封装JWT令牌的核心操作
- 支持Express中间件创建，便于集成到Web应用
- 提供令牌刷新机制，增强安全性
- 包含角色验证和权限控制功能

**命令总数：19个**

**核心功能** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 生成令牌 | 载荷, 密钥, 选项 | Object, string, Object(可选) | 生成JWT令牌 | string |
| 验证令牌 | 令牌, 密钥, 选项 | string, string/Object, Object(可选) | 验证JWT令牌 | Object |
| 解码令牌 | 令牌, 选项 | string, Object(可选) | 解码JWT令牌（不验证签名） | Object |

**Express中间件** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建认证中间件 | 密钥, 选项 | string/Object, Object(可选) | 为Express生成JWT认证中间件 | Function |
| 创建错误处理器 | 自定义处理 | Function(可选) | 创建JWT错误处理函数 | Function |
| 创建角色验证中间件 | 允许的角色 | Array<string> | 为Express创建角色验证中间件 | Function |

**令牌管理** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 生成刷新令牌 | 用户数据, 刷新密钥, 有效期 | Object, string, number(可选) | 生成刷新令牌 | string |
| 刷新访问令牌 | 刷新令牌, 刷新密钥, 访问密钥, 附加载荷, 访问有效期 | string, string, string, Object(可选), number(可选) | 使用刷新令牌生成新的访问令牌 | Object |
| 设置过期时间 | 时间 | number/string | 设置令牌过期时间 | Object |
| 生成角色令牌 | 用户数据, 密钥, 角色, 有效期 | Object, string, string, number(可选) | 生成具有不同级别的令牌 | string |
| 验证角色令牌 | 令牌, 密钥, 允许的角色 | string, string, Array<string> | 验证角色令牌，检查用户角色 | Object |

**工具函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 加密敏感数据 | 数据, 加密密钥 | Object, string | 加密令牌中的敏感数据 | Object |
| 解密敏感数据 | 加密数据, 加密密钥 | Object, string | 解密令牌中的敏感数据 | Object |
| 从请求提取令牌 | 请求对象, 位置, 名称 | Object, string(可选), string(可选) | 从请求中提取令牌 | string|null |
| 创建配置 | 访问密钥, 刷新密钥, 访问过期时间, 刷新过期时间 | string, string, number(可选), number(可选) | 生成JWT配置对象 | Object |

**附加功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始JWT | 无 | 无 | 获取原始jsonwebtoken模块 | Object |
| 算法常量 | 无 | 无 | 支持的JWT算法常量 | Object |
| 过期时间常量 | 无 | 无 | 预设的过期时间常量（秒） | Object |
| 版本信息 | 无 | 无 | 模块版本和JWT版本 | string |

**使用示例**

```javascript
const 令牌 = require('./zh/后端/令牌/index.js');

// 生成访问令牌
function 生成访问令牌示例() {
  const 用户数据 = {
    id: 1,
    用户名: '张三',
    邮箱: 'zhangsan@example.com'
  };
  const 密钥 = 'your-secret-key';
  const 选项 = 令牌.设置过期时间(令牌.过期时间.一小时);
  
  const 访问令牌 = 令牌.生成令牌(用户数据, 密钥, 选项);
  console.log('生成的访问令牌:', 访问令牌);
  return 访问令牌;
}

// 验证令牌
function 验证令牌示例(令牌字符串) {
  const 密钥 = 'your-secret-key';
  
  try {
    const 解码数据 = 令牌.验证令牌(令牌字符串, 密钥);
    console.log('验证成功，解码数据:', 解码数据);
    return 解码数据;
  } catch (错误) {
    console.error('令牌验证失败:', 错误.message);
    return null;
  }
}

// 令牌刷新机制
async function 刷新令牌示例() {
  const 用户数据 = { id: 1 };
  const 访问密钥 = 'access-secret-key';
  const 刷新密钥 = 'refresh-secret-key';
  
  // 生成初始刷新令牌
  const 初始刷新令牌 = 令牌.生成刷新令牌(用户数据, 刷新密钥);
  
  try {
    // 刷新访问令牌
    const 刷新结果 = await 令牌.刷新访问令牌(
      初始刷新令牌,
      刷新密钥,
      访问密钥,
      { 用户名: '张三' },
      令牌.过期时间.一小时
    );
    
    console.log('刷新成功，新访问令牌:', 刷新结果.访问令牌);
    console.log('新刷新令牌:', 刷新结果.刷新令牌);
    console.log('过期时间(秒):', 刷新结果.过期时间);
    
    return 刷新结果;
  } catch (错误) {
    console.error('令牌刷新失败:', 错误.message);
    return null;
  }
}

// Express认证中间件示例
function Express中间件示例() {
  const express = require('express');
  const app = express();
  const 密钥 = 'your-secret-key';
  
  // 创建认证中间件
  const 认证中间件 = 令牌.创建认证中间件(密钥);
  
  // 公开路由（无需认证）
  app.post('/login', (req, res) => {
    // 验证用户凭据...
    const 用户 = { id: 1, 用户名: '张三' };
    
    // 生成访问令牌
    const 访问令牌 = 令牌.生成令牌(
      用户,
      密钥,
      令牌.设置过期时间(令牌.过期时间.一小时)
    );
    
    // 生成刷新令牌
    const 刷新令牌 = 令牌.生成刷新令牌(
      用户,
      'refresh-secret-key',
      令牌.过期时间.两周
    );
    
    res.json({ 访问令牌, 刷新令牌 });
  });
  
  // 受保护路由（需要认证）
  app.get('/protected', 认证中间件, (req, res) => {
    res.json({ 消息: '这是受保护的资源', 用户: req.user });
  });
  
  // 角色验证中间件
  const 需要管理员角色 = 令牌.创建角色验证中间件(['admin', 'superadmin']);
  
  // 管理员路由
  app.get('/admin', 认证中间件, 需要管理员角色, (req, res) => {
    res.json({ 消息: '这是管理员区域', 用户: req.user });
  });
  
  // 错误处理
  app.use(令牌.创建错误处理器());
  
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    console.log(`服务器运行在端口 ${PORT}`);
  });
}

// 加密敏感数据示例
function 加密数据示例() {
  const 敏感数据 = {
    信用卡号: '4111 1111 1111 1111',
    有效期: '12/25',
    CVV: '123'
  };
  
  const 加密密钥 = 'encryption-secret-key';
  const 加密结果 = 令牌.加密敏感数据(敏感数据, 加密密钥);
  
  console.log('加密结果:', 加密结果);
  
  // 将加密数据放入令牌
  const 令牌载荷 = {
    用户ID: 1,
    加密信息: 加密结果
  };
  
  const 安全令牌 = 令牌.生成令牌(令牌载荷, 'token-secret-key');
  
  // 解密示例
  const 解码数据 = 令牌.验证令牌(安全令牌, 'token-secret-key');
  const 解密数据 = 令牌.解密敏感数据(解码数据.加密信息, 加密密钥);
  
  console.log('解密结果:', 解密数据);
}

// 从请求中提取令牌示例
function 提取令牌示例() {
  // 模拟Express请求对象
  const 请求对象 = {
    headers: {
      'authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
    },
    cookies: {
      'token': 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
    },
    body: {
      'auth_token': 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
    }
  };
  
  // 从不同位置提取令牌
  const 从头部提取 = 令牌.从请求提取令牌(请求对象, 'header');
  const 从Cookie提取 = 令牌.从请求提取令牌(请求对象, 'cookie', 'token');
  const 从Body提取 = 令牌.从请求提取令牌(请求对象, 'body', 'auth_token');
  
  console.log('从头部提取的令牌:', 从头部提取);
  console.log('从Cookie提取的令牌:', 从Cookie提取);
  console.log('从Body提取的令牌:', 从Body提取);
}

// 生成和验证角色令牌示例
function 角色令牌示例() {
  const 用户数据 = {
    id: 1,
    用户名: 'admin',
    部门: 'IT'
  };
  
  // 生成管理员令牌
  const 管理员令牌 = 令牌.生成角色令牌(
    用户数据,
    'role-secret-key',
    'admin',
    令牌.过期时间.一天
  );
  
  // 生成普通用户令牌
  const 用户令牌 = 令牌.生成角色令牌(
    用户数据,
    'role-secret-key',
    'user',
    令牌.过期时间.一天
  );
  
  try {
    // 验证管理员令牌是否有权限访问管理员资源
    const 管理员验证结果 = 令牌.验证角色令牌(
      管理员令牌,
      'role-secret-key',
      ['admin', 'superadmin']
    );
    console.log('管理员验证成功:', 管理员验证结果);
    
    // 验证普通用户令牌是否有权限访问管理员资源（应该失败）
    const 用户验证结果 = 令牌.验证角色令牌(
      用户令牌,
      'role-secret-key',
      ['admin', 'superadmin']
    );
  } catch (错误) {
    console.error('角色验证失败:', 错误.message);
  }
}

// 创建统一配置示例
function 配置管理示例() {
  // 创建JWT配置
  const 配置 = 令牌.创建配置(
    'access-secret-key',
    'refresh-secret-key',
    令牌.过期时间.一小时,
    令牌.过期时间.一个月
  );
  
  console.log('JWT配置:', 配置);
  
  // 使用配置生成令牌
  const 令牌字符串 = 令牌.生成令牌(
    { 用户ID: 1 },
    配置.访问密钥,
    令牌.设置过期时间(配置.访问过期时间)
  );
  
  console.log('使用配置生成的令牌:', 令牌字符串);
}

// 获取模块信息
function 获取模块信息() {
  console.log('模块版本:', 令牌.版本);
  console.log('JWT库版本:', 令牌.JWT版本);
  console.log('支持的算法:', 令牌.算法);
  console.log('预设过期时间:', 令牌.过期时间);
}

// 取消注释以运行相应示例
// 生成访问令牌示例();
// 验证令牌示例('your-token-string');
// 刷新令牌示例();
// 加密数据示例();
// 提取令牌示例();
// 角色令牌示例();
// 配置管理示例();
// 获取模块信息();
```

#### 日志输出操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/日志_输出/index.js
- 功能: 基于Morgan和Winston库的中文API封装，提供完整的日志记录、HTTP请求日志和错误处理功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 集成Morgan和Winston，支持HTTP请求日志和自定义日志
- 支持多级别日志记录（debug、info、warn、error）
- 提供Express中间件，便于集成到Web应用
- 支持文件轮转、带标签日志和性能监控

**命令总数：24个**

**核心函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建日志记录器 | 配置 | Object(可选) | 创建Winston日志记录器实例 | Object |
| 创建日志系统 | 配置 | Object(可选) | 创建完整的日志系统 | Object |

**日志记录函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 记录调试信息 | 日志记录器, 消息, 元数据 | Object, string, Object(可选) | 记录调试级别的日志 | undefined |
| 记录信息 | 日志记录器, 消息, 元数据 | Object, string, Object(可选) | 记录信息级别的日志 | undefined |
| 记录警告 | 日志记录器, 消息, 元数据 | Object, string, Object(可选) | 记录警告级别的日志 | undefined |
| 记录错误 | 日志记录器, 错误, 元数据 | Object, string/Error, Object(可选) | 记录错误级别的日志 | undefined |
| 记录严重错误 | 日志记录器, 错误, 元数据 | Object, string/Error, Object(可选) | 记录严重错误级别的日志 | undefined |

**Express中间件** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建HTTP日志中间件 | 应用, 选项, 日志记录器 | Object, Object(可选), Object(可选) | 创建HTTP请求日志中间件 | undefined |
| 创建错误处理中间件 | 日志记录器 | Object | 创建Express错误处理中间件 | Function |
| 创建性能监控中间件 | 日志记录器 | Object | 创建API性能监控中间件 | Function |

**工具函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建带标签日志 | 日志记录器, 标签 | Object, string | 创建带标签的日志函数集 | Object |
| 设置日志级别 | 日志记录器, 级别 | Object, string | 设置日志记录器的级别 | undefined |
| 添加日志传输 | 日志记录器, 传输 | Object, Object | 向日志记录器添加传输 | undefined |
| 移除日志传输 | 日志记录器, 传输 | Object, Object | 从日志记录器移除传输 | undefined |

**传输创建函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建文件传输 | 文件名, 选项 | string, Object(可选) | 创建文件日志传输 | Object |
| 创建控制台传输 | 选项 | Object(可选) | 创建控制台日志传输 | Object |

**辅助函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建日志格式 | 日期格式, 使用颜色 | string(可选), boolean(可选) | 创建自定义日志格式 | Object |
| 记录API请求 | 日志记录器, 请求, 响应, 处理时间 | Object, Object, Object, number | 记录API请求详细信息 | undefined |

**附加功能** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始Morgan | 无 | 无 | 获取原始Morgan模块 | Object |
| 获取原始Winston | 无 | 无 | 获取原始Winston模块 | Object |
| 日志级别常量 | 无 | 无 | 日志级别常量定义 | Object |

**使用示例**

```javascript
const 日志 = require('./zh/后端/日志_输出/index.js');

// 基本日志记录示例
function 基本日志示例() {
  // 创建日志记录器
  const 日志记录器 = 日志.创建日志记录器({
    日志级别: 'debug',
    应用名称: '示例应用',
    日志文件: './logs/app.log',
    错误日志文件: './logs/error.log'
  });
  
  // 记录不同级别的日志
  日志.记录调试信息(日志记录器, '这是一条调试日志', { 详细信息: '调试阶段' });
  日志.记录信息(日志记录器, '应用启动成功');
  日志.记录警告(日志记录器, '资源使用率过高', { CPU使用率: '85%', 内存: '700MB' });
  日志.记录错误(日志记录器, '数据库连接失败', { 错误码: 5001 });
  
  // 记录错误对象
  try {
    throw new Error('测试错误');
  } catch (错误) {
    日志.记录严重错误(日志记录器, 错误, { 操作: '数据处理' });
  }
}

// Express集成示例
function Express集成示例() {
  const express = require('express');
  const app = express();
  
  // 创建日志系统
  const 日志系统 = 日志.创建日志系统({
    日志级别: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
    应用名称: 'Express示例应用'
  });
  
  // 添加HTTP请求日志中间件
  日志系统.创建HTTP日志中间件(app, {
    格式: 'combined' // 可选: 'combined', 'common', 'dev', 'short', 'tiny'
  });
  
  // 添加性能监控中间件
  app.use(日志系统.创建性能监控中间件());
  
  // 路由示例
  app.get('/', (req, res) => {
    日志系统.信息('首页访问', { IP: req.ip });
    res.send('Hello World!');
  });
  
  app.get('/error', (req, res) => {
    throw new Error('测试错误路由');
  });
  
  // 添加错误处理中间件（必须放在所有路由之后）
  app.use(日志系统.创建错误处理中间件());
  
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    日志系统.信息(`服务器运行在端口 ${PORT}`);
  });
}

// 带标签日志示例
function 带标签日志示例() {
  const 日志记录器 = 日志.创建日志记录器();
  
  // 为不同模块创建带标签的日志函数
  const 用户日志 = 日志.创建带标签日志(日志记录器, '用户模块');
  const 订单日志 = 日志.创建带标签日志(日志记录器, '订单模块');
  const 支付日志 = 日志.创建带标签日志(日志记录器, '支付模块');
  
  // 使用带标签的日志
  用户日志.信息('用户登录成功', { 用户名: '张三' });
  订单日志.警告('订单处理延迟', { 订单ID: 'ORD123', 延迟时间: '2s' });
  支付日志.错误('支付失败', { 交易ID: 'TXN456', 错误原因: '余额不足' });
}

// 自定义日志传输示例
function 自定义传输示例() {
  const 日志记录器 = 日志.创建日志记录器({
    日志级别: 'info'
  });
  
  // 创建自定义文件传输
  const 数据库日志传输 = 日志.创建文件传输('./logs/database.log', {
    level: 'info',
    maxsize: 5242880, // 5MB
    maxFiles: 5
  });
  
  const 安全日志传输 = 日志.创建文件传输('./logs/security.log', {
    level: 'warn'
  });
  
  // 添加传输
  日志.添加日志传输(日志记录器, 数据库日志传输);
  日志.添加日志传输(日志记录器, 安全日志传输);
  
  // 记录日志到不同传输
  日志.记录信息(日志记录器, '数据库连接成功');
  日志.记录警告(日志记录器, '可疑登录尝试', { IP: '192.168.1.100', 用户名: 'unknown' });
  
  // 移除传输
  // 日志.移除日志传输(日志记录器, 数据库日志传输);
}

// 自定义日志格式示例
function 自定义格式示例() {
  const 彩色格式 = 日志.创建日志格式('YYYY-MM-DD HH:mm:ss', true);
  const 普通格式 = 日志.创建日志格式('YYYY-MM-DD');
  
  // 创建自定义控制台传输
  const 彩色控制台传输 = 日志.创建控制台传输({
    format: 彩色格式,
    level: 'debug'
  });
  
  // 创建自定义文件传输
  const 详细文件传输 = 日志.创建文件传输('./logs/detailed.log', {
    format: 普通格式,
    level: 'info'
  });
  
  // 创建日志记录器
  const 自定义记录器 = 日志.创建日志记录器();
  
  // 移除默认传输
  自定义记录器.transports.forEach(传输 => {
    日志.移除日志传输(自定义记录器, 传输);
  });
  
  // 添加自定义传输
  日志.添加日志传输(自定义记录器, 彩色控制台传输);
  日志.添加日志传输(自定义记录器, 详细文件传输);
  
  // 测试日志
  日志.记录信息(自定义记录器, '使用自定义格式');
}

// API请求记录示例
function API请求记录示例() {
  const 日志记录器 = 日志.创建日志记录器();
  
  // 模拟API请求对象
  const 请求 = {
    method: 'POST',
    originalUrl: '/api/users',
    ip: '192.168.1.100',
    headers: {
      'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'content-type': 'application/json'
    },
    user: { id: 123 }
  };
  
  // 模拟响应对象
  const 响应 = { statusCode: 201 };
  
  // 记录请求
  日志.记录API请求(日志记录器, 请求, 响应, 150); // 150ms处理时间
  
  // 错误状态码测试
  响应.statusCode = 500;
  日志.记录API请求(日志记录器, 请求, 响应, 1000);
}

// 日志级别动态调整示例
function 日志级别调整示例() {
  const 日志记录器 = 日志.创建日志记录器({
    日志级别: 'info'
  });
  
  // 初始配置下，debug日志不会显示
  日志.记录调试信息(日志记录器, '这条调试日志不会显示');
  日志.记录信息(日志记录器, '这条信息日志会显示');
  
  // 动态调整日志级别
  日志.设置日志级别(日志记录器, 'debug');
  console.log('已将日志级别调整为debug');
  
  // 现在debug日志会显示
  日志.记录调试信息(日志记录器, '现在这条调试日志会显示');
  
  // 生产环境调整
  const 设置生产环境 = () => {
    日志.设置日志级别(日志记录器, 日志.日志级别.ERROR);
    console.log('已切换到生产环境日志级别');
  };
  
  // 取消注释以测试
  // 设置生产环境();
  // 日志.记录信息(日志记录器, '生产环境下这条信息不会显示');
  // 日志.记录错误(日志记录器, '生产环境下只有错误会显示');
}

// 完整日志系统示例
function 完整日志系统示例() {
  // 创建完整的日志系统
  const 应用日志 = 日志.创建日志系统({
    日志级别: 'debug',
    应用名称: '完整应用示例',
    日志文件: './logs/app.log',
    错误日志文件: './logs/error.log'
  });
  
  // 使用日志系统
  应用日志.信息('应用初始化');
  
  // 创建模块专用日志
  const 数据库模块日志 = 应用日志.创建带标签日志('数据库');
  const API模块日志 = 应用日志.创建带标签日志('API');
  
  // 数据库操作日志
  数据库模块日志.调试('连接数据库');
  try {
    // 模拟数据库操作
    数据库模块日志.信息('数据查询成功', { 表名: 'users', 记录数: 42 });
  } catch (错误) {
    数据库模块日志.错误('数据库操作失败', { 错误: 错误.message });
  }
  
  // 模拟API调用
  API模块日志.信息('API请求处理开始', { 端点: '/api/data' });
  
  // 性能监控示例
  const 开始时间 = Date.now();
  // 模拟耗时操作
  setTimeout(() => {
    const 处理时间 = Date.now() - 开始时间;
    API模块日志.信息('API请求处理完成', { 处理时间: 处理时间 + 'ms' });
  }, 100);
  
  // 获取原始模块（如果需要使用底层功能）
  const Winston = 应用日志.获取原始Winston();
  console.log('Winston版本:', Winston.version);
}

// 错误处理示例
function 错误处理示例() {
  const 日志记录器 = 日志.创建日志记录器();
  
  // 创建错误处理函数
  function 处理应用错误(错误, 上下文) {
    // 根据错误类型记录不同级别的日志
    if (错误 instanceof SyntaxError) {
      日志.记录严重错误(日志记录器, 错误, { 上下文: 上下文, 类型: '语法错误' });
    } else if (错误.code === 'ECONNREFUSED') {
      日志.记录错误(日志记录器, 错误, { 上下文: 上下文, 类型: '连接错误' });
    } else {
      日志.记录警告(日志记录器, 错误, { 上下文: 上下文 });
    }
    
    // 返回标准化的错误响应
    return {
      错误码: 错误.code || 'UNKNOWN_ERROR',
      消息: 错误.message,
      时间戳: new Date().toISOString()
    };
  }
  
  // 测试不同类型的错误
  const 语法错误 = new SyntaxError('无效的JSON格式');
  const 连接错误 = new Error('无法连接到服务');
  连接错误.code = 'ECONNREFUSED';
  const 一般错误 = new Error('操作失败');
  
  console.log('语法错误处理结果:', 处理应用错误(语法错误, '配置文件解析'));
  console.log('连接错误处理结果:', 处理应用错误(连接错误, 'API调用'));
  console.log('一般错误处理结果:', 处理应用错误(一般错误, '用户操作'));
}

// 取消注释以运行相应示例
// 基本日志示例();
// Express集成示例();
// 带标签日志示例();
// 自定义传输示例();
// 自定义格式示例();
// API请求记录示例();
// 日志级别调整示例();
// 完整日志系统示例();
// 错误处理示例();
```


#### 数据库操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/数据库操作/index.js
- 功能: 基于Sequelize ORM框架的中文API封装，提供完整的数据库连接、模型定义、查询和事务操作功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 集成Sequelize ORM，支持主流关系型数据库
- 支持模型定义、关联配置、事务管理和数据迁移
- 提供丰富的查询操作符和数据类型
- 支持事务处理、批量操作和性能优化

**命令总数：33个**

**数据库连接函数** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建连接 | 数据库名称, 用户名, 密码, 配置 | string, string, string, Object(可选) | 创建Sequelize数据库连接实例 | Object |
| 测试连接 | 连接实例 | Object | 测试数据库连接是否成功 | Promise |
| 关闭连接 | 连接实例 | Object | 关闭数据库连接 | Promise |
| 同步数据库 | 连接实例, 选项 | Object, Object(可选) | 同步数据库模型到数据库 | Promise |
| 强制同步数据库 | 连接实例 | Object | 强制同步（删除并重建表） | Promise |
| 自动迁移 | 连接实例 | Object | 自动迁移数据库结构 | Promise |
| 获取所有表 | 连接实例 | Object | 查询数据库中的所有表 | Promise<Array> |

**模型管理函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 定义模型 | 连接实例, 模型名称, 属性, 选项 | Object, string, Object, Object(可选) | 定义数据库模型 | Object |
| 添加关联 | 源模型, 目标模型, 关联类型, 选项 | Object, Object, string, Object(可选) | 为模型添加关联关系 | Object |
| 创建查询构建器 | 模型 | Object | 创建查询构建器 | Object |
| 获取原始Sequelize | 无 | 无 | 获取原始Sequelize模块 | Object |

**数据操作函数** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 查询所有 | 模型, 选项 | Object, Object(可选) | 查询模型的所有记录 | Promise<Array> |
| 根据ID查询 | 模型, id, 选项 | Object, any, Object(可选) | 根据ID查询单条记录 | Promise<Object> |
| 创建记录 | 模型, 数据, 选项 | Object, Object, Object(可选) | 创建单条记录 | Promise<Object> |
| 批量创建 | 模型, 数据数组, 选项 | Object, Array, Object(可选) | 批量创建多条记录 | Promise<Array> |
| 更新记录 | 模型, 更新数据, 选项 | Object, Object, Object(可选) | 更新记录 | Promise<Array> |
| 删除记录 | 模型, 选项 | Object, Object(可选) | 删除记录 | Promise<number> |
| 计数 | 模型, 选项 | Object, Object(可选) | 计算记录总数 | Promise<number> |

**事务管理函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建事务 | 连接实例, 选项 | Object, Object(可选) | 创建数据库事务 | Promise<Object> |

**常量定义** (3个)

| 常量名 | 类型 | 功能描述 | 包含项数 |
|-------|-----|---------|--------|
| 数据类型 | Object | 支持的数据类型定义 | 16个 |
| 操作符 | Object | 查询条件操作符定义 | 17个 |
| 关联类型 | Object | 模型关联类型定义 | 4个 |

**使用示例**

```javascript
const 数据库 = require('./zh/后端/数据库操作/index.js');

// 基本连接示例
function 基本连接示例() {
  // 创建数据库连接
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql', // 可选: 'mysql', 'postgres', 'sqlite', 'mssql'
    pool: {
      max: 5,
      min: 0,
      acquire: 30000,
      idle: 10000
    },
    logging: console.log // 可选: 日志函数
  });
  
  // 测试连接
  数据库.测试连接(连接)
    .then(() => {
      console.log('数据库连接成功');
      // 关闭连接
      return 数据库.关闭连接(连接);
    })
    .catch(err => {
      console.error('数据库连接失败:', err);
    });
}

// 模型定义与同步示例
function 模型定义示例() {
  // 创建连接
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  // 定义用户模型
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: {
      type: 数据库.数据类型.整数,
      primaryKey: true,
      autoIncrement: true
    },
    用户名: {
      type: 数据库.数据类型.字符串,
      allowNull: false,
      unique: true
    },
    密码: {
      type: 数据库.数据类型.字符串,
      allowNull: false
    },
    邮箱: {
      type: 数据库.数据类型.字符串,
      allowNull: false,
      validate: {
        isEmail: true
      }
    },
    年龄: {
      type: 数据库.数据类型.整数,
      defaultValue: 18
    },
    创建时间: {
      type: 数据库.数据类型.日期时间,
      defaultValue: 数据库.获取原始Sequelize().NOW
    }
  }, {
    tableName: 'users', // 自定义表名
    timestamps: true // 自动添加时间戳
  });
  
  // 同步数据库
  数据库.同步数据库(连接)
    .then(() => {
      console.log('数据库同步成功');
      return 数据库.关闭连接(连接);
    })
    .catch(err => {
      console.error('数据库同步失败:', err);
    });
}

// 模型关联示例
function 模型关联示例() {
  // 创建连接
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  // 定义模型
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: {
      type: 数据库.数据类型.整数,
      primaryKey: true,
      autoIncrement: true
    },
    用户名: { type: 数据库.数据类型.字符串 }
  });
  
  const 文章 = 数据库.定义模型(连接, '文章', {
    id: {
      type: 数据库.数据类型.整数,
      primaryKey: true,
      autoIncrement: true
    },
    标题: { type: 数据库.数据类型.字符串 },
    内容: { type: 数据库.数据类型.文本 }
  });
  
  const 评论 = 数据库.定义模型(连接, '评论', {
    id: {
      type: 数据库.数据类型.整数,
      primaryKey: true,
      autoIncrement: true
    },
    内容: { type: 数据库.数据类型.文本 }
  });
  
  // 添加关联
  // 一对多: 用户 -> 文章
  数据库.添加关联(用户, 文章, '一对多', {
    foreignKey: '用户ID',
    as: '文章列表'
  });
  
  // 多对一: 文章 -> 用户
  数据库.添加关联(文章, 用户, '多对一', {
    foreignKey: '用户ID',
    as: '作者'
  });
  
  // 一对多: 文章 -> 评论
  数据库.添加关联(文章, 评论, '一对多', {
    foreignKey: '文章ID',
    as: '评论列表'
  });
  
  // 多对一: 评论 -> 文章
  数据库.添加关联(评论, 文章, '多对一', {
    foreignKey: '文章ID',
    as: '所属文章'
  });
  
  // 一对一: 用户 -> 个人资料（假设有个人资料模型）
  // 数据库.添加关联(用户, 个人资料, '一对一', { ... });
  
  // 多对多: 用户 -> 角色（假设有角色模型）
  // 数据库.添加关联(用户, 角色, '多对多', { through: '用户角色' });
  
  console.log('模型关联配置完成');
}

// 基本CRUD操作示例
async function CRUD操作示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  // 定义用户模型
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串, allowNull: false },
    年龄: { type: 数据库.数据类型.整数 }
  });
  
  try {
    // 同步数据库
    await 数据库.同步数据库(连接);
    
    // 创建记录
    const 新用户 = await 数据库.创建记录(用户, {
      用户名: '张三',
      年龄: 25
    });
    console.log('创建的用户:', 新用户.toJSON());
    
    // 查询所有记录
    const 所有用户 = await 数据库.查询所有(用户);
    console.log('所有用户数量:', 所有用户.length);
    
    // 根据ID查询
    const 用户详情 = await 数据库.根据ID查询(用户, 新用户.id);
    console.log('用户详情:', 用户详情 ? 用户详情.toJSON() : '未找到');
    
    // 更新记录
    const 更新结果 = await 数据库.更新记录(用户, {
      年龄: 26
    }, {
      where: { id: 新用户.id }
    });
    console.log('更新影响行数:', 更新结果[0]);
    
    // 计数
    const 用户数量 = await 数据库.计数(用户, {
      where: { 年龄: { [数据库.操作符.大于]: 20 } }
    });
    console.log('年龄大于20的用户数:', 用户数量);
    
    // 删除记录
    const 删除结果 = await 数据库.删除记录(用户, {
      where: { id: 新用户.id }
    });
    console.log('删除影响行数:', 删除结果);
    
  } catch (错误) {
    console.error('操作失败:', 错误);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 批量操作示例
async function 批量操作示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串 },
    状态: { type: 数据库.数据类型.布尔值, defaultValue: true }
  });
  
  try {
    await 数据库.同步数据库(连接);
    
    // 批量创建
    const 批量用户 = await 数据库.批量创建(用户, [
      { 用户名: '批量用户1' },
      { 用户名: '批量用户2' },
      { 用户名: '批量用户3' }
    ], {
      validate: true, // 创建前验证
      individualHooks: true // 触发单个钩子
    });
    console.log('批量创建的用户数量:', 批量用户.length);
    
    // 批量更新
    const 批量更新结果 = await 数据库.更新记录(用户, {
      状态: false
    }, {
      where: {
        用户名: { [数据库.操作符.在]: ['批量用户1', '批量用户2'] }
      }
    });
    console.log('批量更新影响行数:', 批量更新结果[0]);
    
    // 批量删除
    const 批量删除结果 = await 数据库.删除记录(用户, {
      where: {
        状态: { [数据库.操作符.等于]: false }
      }
    });
    console.log('批量删除影响行数:', 批量删除结果);
    
  } catch (错误) {
    console.error('批量操作失败:', 错误);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 事务处理示例
async function 事务示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串 },
    余额: { type: 数据库.数据类型.浮点数, defaultValue: 0 }
  });
  
  try {
    await 数据库.同步数据库(连接);
    
    // 创建事务
    const 事务 = await 数据库.创建事务(连接, {
      isolationLevel: 'READ COMMITTED' // 可选的隔离级别
    });
    
    try {
      // 在事务中创建用户
      const 用户1 = await 数据库.创建记录(用户, {
        用户名: '转账用户1',
        余额: 1000
      }, { transaction });
      
      const 用户2 = await 数据库.创建记录(用户, {
        用户名: '转账用户2',
        余额: 500
      }, { transaction });
      
      // 转账操作（减少用户1余额，增加用户2余额）
      await 数据库.更新记录(用户, {
        余额: 数据库.获取原始Sequelize().literal('余额 - 200')
      }, {
        where: { id: 用户1.id },
        transaction
      });
      
      await 数据库.更新记录(用户, {
        余额: 数据库.获取原始Sequelize().literal('余额 + 200')
      }, {
        where: { id: 用户2.id },
        transaction
      });
      
      // 提交事务
      await 事务.commit();
      console.log('事务提交成功，转账完成');
      
    } catch (事务错误) {
      // 回滚事务
      await 事务.rollback();
      console.error('事务回滚:', 事务错误);
    }
    
  } catch (错误) {
    console.error('操作失败:', 错误);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 复杂查询示例
async function 复杂查询示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串 },
    年龄: { type: 数据库.数据类型.整数 },
    注册时间: { type: 数据库.数据类型.日期时间 }
  });
  
  try {
    await 数据库.同步数据库(连接);
    
    // 复杂查询条件
    const 复杂查询结果 = await 数据库.查询所有(用户, {
      // 过滤条件
      where: {
        [数据库.操作符.或]: [
          {
            年龄: {
              [数据库.操作符.大于]: 20,
              [数据库.操作符.小于]: 30
            }
          },
          {
            用户名: {
              [数据库.操作符.喜欢]: '%张%'
            }
          }
        ],
        [数据库.操作符.不在]: {
          id: [1, 2, 3]
        }
      },
      
      // 排序
      order: [
        ['注册时间', 'DESC'],
        ['年龄', 'ASC']
      ],
      
      // 分页
      limit: 10,
      offset: 0,
      
      // 字段选择
      attributes: ['id', '用户名', '年龄'],
      
      // 分组
      // group: ['年龄'],
      
      // 子查询
      // include: [...],
      
      // 原始查询选项
      raw: false, // 返回实例对象而非原始数据
      logging: console.log // 记录SQL
    });
    
    console.log('复杂查询结果数量:', 复杂查询结果.length);
    
  } catch (错误) {
    console.error('查询失败:', 错误);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 关联查询示例
async function 关联查询示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  // 定义关联模型
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串 }
  });
  
  const 文章 = 数据库.定义模型(连接, '文章', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    标题: { type: 数据库.数据类型.字符串 },
    内容: { type: 数据库.数据类型.文本 },
    用户ID: { type: 数据库.数据类型.整数 }
  });
  
  // 设置关联
  数据库.添加关联(用户, 文章, '一对多', { as: '文章列表' });
  数据库.添加关联(文章, 用户, '多对一', { as: '作者' });
  
  try {
    await 数据库.同步数据库(连接);
    
    // 包含关联数据查询用户
    const 用户列表 = await 数据库.查询所有(用户, {
      include: [{
        model: 文章,
        as: '文章列表',
        attributes: ['id', '标题'], // 只选择文章的特定字段
        where: { // 过滤关联数据
          标题: { [数据库.操作符.喜欢]: '%教程%' }
        }
      }],
      where: {
        用户名: { [数据库.操作符.不等于]: null }
      }
    });
    
    // 包含关联数据查询文章
    const 文章列表 = await 数据库.查询所有(文章, {
      include: [{
        model: 用户,
        as: '作者',
        attributes: ['id', '用户名']
      }],
      order: [['id', 'DESC']]
    });
    
    console.log('用户列表（含文章）数量:', 用户列表.length);
    console.log('文章列表（含作者）数量:', 文章列表.length);
    
    // 嵌套关联查询示例
    // const 复杂查询 = await 数据库.查询所有(模型A, {
    //   include: [{
    //     model: 模型B,
    //     as: 'B列表',
    //     include: [{
    //       model: 模型C,
    //       as: 'C列表'
    //     }]
    //   }]
    // });
    
  } catch (错误) {
    console.error('关联查询失败:', 错误);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 数据迁移示例
async function 数据迁移示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false
  });
  
  // 定义更新后的模型（添加新字段）
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串 },
    邮箱: { type: 数据库.数据类型.字符串 }, // 新增字段
    电话: { type: 数据库.数据类型.字符串 }, // 新增字段
    创建时间: { type: 数据库.数据类型.日期时间 },
    更新时间: { type: 数据库.数据类型.日期时间 } // 新增字段
  });
  
  try {
    // 使用自动迁移（不会删除已有数据）
    console.log('开始数据库迁移...');
    await 数据库.自动迁移(连接);
    console.log('数据库迁移成功！');
    
    // 获取所有表信息
    const 表信息 = await 数据库.获取所有表(连接);
    console.log('数据库中的表:', 表信息);
    
  } catch (错误) {
    console.error('数据迁移失败:', 错误);
    
    // 注意：强制同步会删除所有数据，谨慎使用
    // await 数据库.强制同步数据库(连接);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 高级功能示例
async function 高级功能示例() {
  const 连接 = 数据库.创建连接('test_db', 'admin', 'password', {
    host: 'localhost',
    dialect: 'mysql',
    logging: false,
    timezone: '+08:00', // 设置时区
    pool: {
      max: 10,
      min: 2,
      acquire: 30000,
      idle: 10000
    }
  });
  
  const 用户 = 数据库.定义模型(连接, '用户', {
    id: { type: 数据库.数据类型.整数, primaryKey: true, autoIncrement: true },
    用户名: { type: 数据库.数据类型.字符串 },
    分数: { type: 数据库.数据类型.整数 }
  }, {
    // 模型钩子
    hooks: {
      beforeCreate: (用户实例) => {
        console.log('创建前钩子:', 用户实例.用户名);
      },
      afterCreate: (用户实例) => {
        console.log('创建后钩子:', 用户实例.id);
      }
    }
  });
  
  try {
    await 数据库.同步数据库(连接);
    
    // 使用查询构建器
    const 查询构建器 = 数据库.创建查询构建器(用户);
    
    // 原始SQL查询
    const 原始查询结果 = await 连接.query(
      'SELECT * FROM `用户` WHERE `分数` > :分数',
      {
        replacements: { 分数: 60 },
        type: 数据库.获取原始Sequelize().QueryTypes.SELECT
      }
    );
    console.log('原始查询结果数量:', 原始查询结果.length);
    
    // 使用Sequelize函数
    const Sequelize = 数据库.获取原始Sequelize();
    
    // 聚合查询示例
    const 聚合结果 = await 数据库.查询所有(用户, {
      attributes: [
        [Sequelize.fn('AVG', Sequelize.col('分数')), '平均分数'],
        [Sequelize.fn('MAX', Sequelize.col('分数')), '最高分数'],
        [Sequelize.fn('MIN', Sequelize.col('分数')), '最低分数'],
        [Sequelize.fn('SUM', Sequelize.col('分数')), '总分数']
      ],
      raw: true
    });
    console.log('聚合查询结果:', 聚合结果);
    
    // 虚拟字段示例
    // 可以通过Sequelize的getterMethods添加虚拟字段
    
  } catch (错误) {
    console.error('高级功能测试失败:', 错误);
  } finally {
    await 数据库.关闭连接(连接);
  }
}

// 取消注释以运行相应示例
// 基本连接示例();
// 模型定义示例();
// 模型关联示例();
// CRUD操作示例();
// 批量操作示例();
// 事务示例();
// 复杂查询示例();
// 关联查询示例();
// 数据迁移示例();
// 高级功能示例();
```
#### 文件上传操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/文件上传/index.js
- 功能: 基于Multer的文件上传中间件中文API封装，提供完整的文件上传、过滤、存储和管理功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 集成Multer中间件，支持Express框架
- 支持单文件、多文件、多字段文件上传
- 提供丰富的文件过滤、命名和目录管理功能
- 内置预配置的图片、文档、视频上传器

**命令总数：31个**

**核心函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建上传器 | 配置 | Object(可选) | 创建Multer实例 | Object |
| 创建存储引擎 | 选项 | Object(可选) | 创建Multer存储引擎 | Object |

**上传中间件** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 单文件上传 | 上传器, 字段名, 选项 | Object, string, Object(可选) | 创建单个文件上传中间件 | Function |
| 多文件上传 | 上传器, 字段名, 最大数量 | Object, string, number | 创建多个文件上传中间件 | Function |
| 多字段上传 | 上传器, 字段配置 | Object, Array | 创建多字段文件上传中间件 | Function |
| 上传所有文件 | 上传器 | Object | 上传所有文件中间件 | Function |
| 不处理文件 | 上传器 | Object | 不处理文件上传 | Function |

**文件过滤** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建图片过滤 | 允许的格式 | Array(可选) | 创建图片文件过滤函数 | Function |
| 创建视频过滤 | 允许的格式 | Array(可选) | 创建视频文件过滤函数 | Function |
| 创建文档过滤 | 允许的格式 | Array(可选) | 创建文档文件过滤函数 | Function |
| 创建自定义文件过滤 | 允许的扩展名, 允许的MIME类型 | Array(可选), Array(可选) | 创建自定义文件过滤函数 | Function |

**文件名生成** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 生成唯一文件名 | 前缀 | string(可选) | 生成唯一文件名 | Function |
| 保留原始文件名 | 无 | 无 | 保留原始文件名（添加时间戳避免冲突） | Function |

**目录管理** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 根据用户ID创建目录 | 基础目录 | string(可选) | 根据用户ID生成上传目录 | Object |
| 根据日期创建目录 | 基础目录 | string(可选) | 根据日期创建上传目录 | Object |

**工具函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取上传文件信息 | 请求 | Object | 获取上传文件信息 | Object |
| 创建上传错误处理中间件 | 无 | 无 | 创建文件上传错误处理中间件 | Function |
| 创建文件大小限制 | 最大大小MB | number | 创建限制文件大小的选项 | Object |
| 检查文件是否存在 | 文件路径 | string | 检查文件是否存在 | boolean |
| 删除上传文件 | 文件路径 | string | 删除上传的文件 | boolean |
| 生成文件访问URL | 文件, 基础URL, 路由前缀 | Object, string(可选), string(可选) | 生成文件访问URL | string |

**预配置上传器** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建图片上传器 | 选项 | Object(可选) | 创建预配置的图片上传器 | Object |
| 创建文档上传器 | 选项 | Object(可选) | 创建预配置的文档上传器 | Object |
| 创建视频上传器 | 选项 | Object(可选) | 创建预配置的视频上传器 | Object |

**获取原始模块和常量** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始Multer | 无 | 无 | 获取原始Multer模块 | Object |
| 文件类型.图片 | 无 | 无 | 预定义图片文件类型数组 | Array |
| 文件类型.视频 | 无 | 无 | 预定义视频文件类型数组 | Array |
| 文件类型.文档 | 无 | 无 | 预定义文档文件类型数组 | Array |
| 文件类型.压缩包 | 无 | 无 | 预定义压缩包文件类型数组 | Array |
| 错误代码 | 无 | 无 | Multer错误代码常量对象 | Object |

**使用示例**

```javascript
// 导入模块
const 文件上传 = require('./zh/后端/文件上传/index');
const express = require('express');
const 应用 = express();

// 基本文件上传示例
function 基本文件上传示例() {
  // 创建基本上传器
  const 上传器 = 文件上传.创建上传器({
    限制: 文件上传.创建文件大小限制(5) // 5MB
  });
  
  // 单文件上传
  应用.post('/upload/single', 
    文件上传.单文件上传(上传器, '文件'),
    文件上传.创建上传错误处理中间件(),
    (请求, 响应) => {
      const 文件信息 = 文件上传.获取上传文件信息(请求);
      响应.json({
        成功: true,
        消息: '文件上传成功',
        数据: 文件信息
      });
    }
  );
  
  // 多文件上传
  应用.post('/upload/multiple', 
    文件上传.多文件上传(上传器, '文件', 5),
    文件上传.创建上传错误处理中间件(),
    (请求, 响应) => {
      const 文件信息 = 文件上传.获取上传文件信息(请求);
      响应.json({
        成功: true,
        消息: '多文件上传成功',
        数据: 文件信息
      });
    }
  );
}

// 自定义存储配置示例
function 自定义存储配置示例() {
  // 创建自定义存储引擎
  const 存储引擎 = 文件上传.创建存储引擎({
    目标目录: 'uploads/custom',
    文件名生成器: 文件上传.生成唯一文件名('custom')
  });
  
  const 上传器 = 文件上传.创建上传器({
    存储引擎: 存储引擎
  });
  
  应用.post('/upload/custom', 
    文件上传.单文件上传(上传器, '文件'),
    (请求, 响应) => {
      // 生成文件访问URL
      const 文件URL = 文件上传.生成文件访问URL(
        请求.file,
        'http://localhost:3000',
        '/uploads'
      );
      
      响应.json({
        成功: true,
        文件URL: 文件URL
      });
    }
  );
}

// 文件过滤示例
function 文件过滤示例() {
  // 创建图片上传器
  const 图片上传 = 文件上传.创建图片上传器({
    上传目录: 'uploads/images',
    最大文件大小: 10, // 10MB
    允许的格式: ['jpg', 'jpeg', 'png', 'webp']
  });
  
  应用.post('/upload/image', 
    图片上传.单文件上传(),
    图片上传.错误处理中间件,
    (请求, 响应) => {
      响应.json({
        成功: true,
        消息: '图片上传成功',
        文件信息: 请求.file
      });
    }
  );
  
  // 文档上传
  const 文档上传 = 文件上传.创建文档上传器({
    上传目录: 'uploads/documents',
    最大文件大小: 20, // 20MB
    保留原始名称: true
  });
  
  应用.post('/upload/document', 
    文档上传.单文件上传(),
    文档上传.错误处理中间件,
    (请求, 响应) => {
      响应.json({
        成功: true,
        消息: '文档上传成功',
        文件信息: 请求.file
      });
    }
  );
}

// 按用户ID或日期组织文件示例
function 组织文件示例() {
  // 按用户ID组织
  const 用户存储引擎 = 文件上传.创建存储引擎({
    目标目录: 文件上传.根据用户ID创建目录('uploads/users'),
    文件名生成器: 文件上传.保留原始文件名()
  });
  
  const 用户上传器 = 文件上传.创建上传器({
    存储引擎: 用户存储引擎
  });
  
  // 按日期组织
  const 日期存储引擎 = 文件上传.创建存储引擎({
    目标目录: 文件上传.根据日期创建目录('uploads/dates')
  });
  
  const 日期上传器 = 文件上传.创建上传器({
    存储引擎: 日期存储引擎
  });
  
  // 中间件保护的路由（需要认证以获取用户ID）
  应用.post('/upload/user', 
    // 认证中间件应该在这里，设置请求.user
    文件上传.单文件上传(用户上传器, '文件'),
    (请求, 响应) => {
      响应.json({ 成功: true });
    }
  );
}

// 自定义文件过滤函数示例
function 自定义文件过滤函数示例() {
  const 自定义过滤 = 文件上传.创建自定义文件过滤(
    ['pdf', 'doc', 'docx'],
    ['application/pdf', 'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document']
  );
  
  const 上传器 = 文件上传.创建上传器({
    文件过滤: 自定义过滤
  });
  
  应用.post('/upload/filtered', 
    文件上传.单文件上传(上传器, '文件'),
    文件上传.创建上传错误处理中间件(),
    (请求, 响应) => {
      响应.json({ 成功: true });
    }
  );
}

// 文件管理操作示例
function 文件管理操作示例() {
  // 文件删除示例
  应用.delete('/file/:文件名', (请求, 响应) => {
    const 文件路径 = path.join('uploads', 请求.params.文件名);
    
    if (文件上传.检查文件是否存在(文件路径)) {
      const 删除成功 = 文件上传.删除上传文件(文件路径);
      if (删除成功) {
        响应.json({ 成功: true, 消息: '文件删除成功' });
      } else {
        响应.status(500).json({ 成功: false, 消息: '文件删除失败' });
      }
    } else {
      响应.status(404).json({ 成功: false, 消息: '文件不存在' });
    }
  });
}

// 启动服务器
function 启动服务器() {
  // 静态文件服务
  应用.use('/uploads', express.static('uploads'));
  
  基本文件上传示例();
  自定义存储配置示例();
  文件过滤示例();
  组织文件示例();
  自定义文件过滤函数示例();
  文件管理操作示例();
  
  应用.listen(3000, () => {
    console.log('服务器运行在 http://localhost:3000');
  });
}

// 启动示例服务器
// 启动服务器();
```
#### 压缩/解压操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/压缩_解压/index.js
- 功能: 基于archiver和unzipper的压缩/解压操作中文API封装，提供完整的文件归档和提取功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持ZIP、TAR、GZIP等多种压缩格式
- 提供文件、目录、流、缓冲区的压缩和解压功能
- 支持分割归档、进度监听、流式处理等高级功能
- 集成错误处理和依赖检查机制

**命令总数：32个**

**基础压缩函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建归档 | 格式 = 'zip', 选项 = {} | string, Object | 创建新的归档实例 | Object |
| 创建ZIP文件 | 输出文件路径, 文件列表 = [], 选项 = {} | string, Array, Object | 创建并保存ZIP文件 | Promise<void> |
| 创建TAR文件 | 输出文件路径, 文件列表 = [], 选项 = {} | string, Array, Object | 创建并保存TAR文件 | Promise<void> |
| 创建归档文件 | 格式, 输出文件路径, 文件列表 = [], 选项 = {} | string, string, Array, Object | 创建并保存归档文件 | Promise<void> |

**文件和目录添加函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 添加文件到归档 | 归档实例, 文件路径, 目标路径 = null | Object, string, string | 添加文件到归档 | Object |
| 添加目录到归档 | 归档实例, 目录路径, 目标路径 = null | Object, string, string | 添加目录到归档 | Object |
| 添加缓冲区到归档 | 归档实例, 数据, 文件名, 选项 = {} | Object, Buffer, string, Object | 添加缓冲区数据到归档 | Object |
| 添加文本到归档 | 归档实例, 文本, 文件名, 选项 = {} | Object, string, string, Object | 添加文本到归档 | Object |

**流处理函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 从流创建归档 | 格式, 输出文件路径, 流数据, 选项 = {} | string, string, Object, Object | 从流创建归档并保存 | Promise<void> |
| 流式输出归档到响应 | 归档实例, 响应对象, 文件名 | Object, Object, string | 流式输出归档到HTTP响应 | Promise<void> |

**高级压缩功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置归档最大大小 | 归档实例, 大小 | Object, number | 设置归档的最大文件大小 | Object |
| 监听归档进度 | 归档实例, 回调函数 | Object, Function | 获取归档进度 | Object |
| 创建分割归档 | 格式, 输出文件路径前缀, 文件列表 = [], 分割大小, 选项 = {} | string, string, Array, number, Object | 创建分割归档 | Promise<Array> |
| 获取归档统计 | 归档实例 | Object | 获取归档统计信息 | Object |

**基本解压函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 解压ZIP文件 | 压缩文件路径, 目标目录 | string, string | 解压ZIP文件到指定目录 | Promise<void> |
| 解压TAR文件 | 压缩文件路径, 目标目录 | string, string | 解压TAR文件 | Promise<void> |
| 解压GZIP文件 | 压缩文件路径, 输出文件路径 | string, string | 解压GZIP文件 | Promise<void> |
| 自动解压 | 压缩文件路径, 目标目录 | string, string | 根据文件扩展名自动解压 | Promise<void> |

**高级解压功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 解压特定文件 | 压缩文件路径, 目标文件, 输出路径 | string, string, string | 解压ZIP文件中的特定文件 | Promise<void> |
| 获取ZIP文件列表 | 压缩文件路径 | string | 读取ZIP文件中的所有文件列表 | Promise<Array> |
| 从ZIP读取文件内容 | 压缩文件路径, 目标文件 | string, string | 从ZIP文件读取文件内容 | Promise<Buffer> |
| 流式解压ZIP | 输入流, 目标目录 | Object, string | 流式解压ZIP文件 | Promise<void> |

**工具函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 验证Unzipper库 | 无 | 无 | 验证unzipper库是否已安装 | boolean |
| 获取原始archiver | 无 | 无 | 获取原始archiver库引用 | Object |
| 获取原始unzipper | 无 | 无 | 获取原始unzipper库引用 | Object |

**使用示例**

**CommonJS模块导入:**
```javascript
const 压缩解压 = require('./zh/后端/压缩_解压/index.js');
```

**基本压缩示例:**
```javascript
// 创建ZIP文件
async function 创建ZIP示例() {
  try {
    // 压缩单个文件
    await 压缩解压.创建ZIP文件('output.zip', ['file1.txt', 'file2.txt']);
    console.log('ZIP文件创建成功');

    // 压缩文件和目录，指定目标路径
    await 压缩解压.创建ZIP文件('archive.zip', [
      'document.pdf',
      { 源路径: 'images/', 目标路径: '资料图片/' },
      { 源路径: 'config.json', 目标路径: '配置/config.json' }
    ]);
    console.log('带目录结构的ZIP文件创建成功');
  } catch (错误) {
    console.error('压缩失败:', 错误.message);
  }
}
```

**高级压缩示例:**
```javascript
// 使用归档实例进行高级操作
async function 高级压缩示例() {
  try {
    // 创建归档实例
    const 归档 = 压缩解压.创建归档('zip');
    
    // 监听进度
    压缩解压.监听归档进度(归档, (进度) => {
      console.log(`压缩进度: ${进度.百分比}%`);
    });
    
    // 添加内容
    压缩解压.添加文件到归档(归档, 'data.csv', '表格数据.csv');
    压缩解压.添加目录到归档(归档, 'reports/', '季度报告');
    压缩解压.添加文本到归档(归档, '这是一个README文件', 'README.txt');
    
    // 设置最大大小限制
    压缩解压.设置归档最大大小(归档, 10 * 1024 * 1024); // 10MB
    
    // 流式输出到HTTP响应
    // 压缩解压.流式输出归档到响应(归档, 响应对象, 'download.zip');
    
    // 或者保存到文件
    await 压缩解压.从流创建归档('zip', 'advanced.zip', {
      流: 归档, 
      文件名: 'archive.zip'
    });
    
    // 获取统计信息
    const 统计 = 压缩解压.获取归档统计(归档);
    console.log('归档统计:', 统计);
  } catch (错误) {
    console.error('高级压缩失败:', 错误.message);
  }
}
```

**基本解压示例:**
```javascript
// 解压文件
async function 基本解压示例() {
  try {
    // 解压ZIP文件
    await 压缩解压.解压ZIP文件('archive.zip', '解压目录');
    console.log('ZIP文件解压成功');
    
    // 自动根据扩展名解压
    await 压缩解压.自动解压('backup.tar.gz', '备份目录');
    console.log('自动解压成功');
  } catch (错误) {
    console.error('解压失败:', 错误.message);
  }
}
```

**高级解压示例:**
```javascript
// 高级解压操作
async function 高级解压示例() {
  try {
    // 获取ZIP文件内容列表
    const 文件列表 = await 压缩解压.获取ZIP文件列表('archive.zip');
    console.log('ZIP文件内容:', 文件列表);
    
    // 解压特定文件
    await 压缩解压.解压特定文件('archive.zip', '文档/报告.pdf', 'extracted_report.pdf');
    console.log('特定文件解压成功');
    
    // 直接读取文件内容
    const 文件内容 = await 压缩解压.从ZIP读取文件内容('archive.zip', '数据.json');
    const 数据 = JSON.parse(文件内容.toString('utf8'));
    console.log('读取的JSON数据:', 数据);
    
    // 流式解压（适用于大文件或从HTTP请求解压）
    // const 输入流 = /* 某处获取的输入流 */;
    // await 压缩解压.流式解压ZIP(输入流, '流式解压目录');
  } catch (错误) {
    console.error('高级解压失败:', 错误.message);
  }
}
```

**分割归档示例:**
```javascript
// 创建分割归档
async function 分割归档示例() {
  try {
    const 生成的文件 = await 压缩解压.创建分割归档(
      'zip',
      'large_archive.part', // 输出文件前缀
      ['large_folder/'], // 要压缩的内容
      10 * 1024 * 1024, // 每个分卷10MB
      { zlib: { level: 9 } } // 压缩选项
    );
    console.log('分割归档生成的文件:', 生成的文件);
  } catch (错误) {
    console.error('分割归档失败:', 错误.message);
  }
}
```

**Express服务器中使用示例:**
```javascript
const express = require('express');
const 应用 = express();
const fs = require('fs');
const 压缩解压 = require('./zh/后端/压缩_解压/index.js');

// 下载压缩文件API
应用.get('/download', async (请求, 响应) => {
  try {
    // 创建临时归档
    const 归档 = 压缩解压.创建归档('zip');
    压缩解压.添加目录到归档(归档, 'public/files/', 'downloads');
    
    // 设置响应头
    响应.attachment('files.zip');
    
    // 流式输出
    await 压缩解压.流式输出归档到响应(归档, 响应, 'files.zip');
  } catch (错误) {
    响应.status(500).json({ 错误: 错误.message });
  }
});

// 上传并解压API
应用.post('/upload-and-extract', async (请求, 响应) => {
  // 这里需要配合文件上传中间件使用
  // 例如使用multer接收文件，然后:
  /*
  try {
    await 压缩解压.解压ZIP文件(请求.file.path, 'extracted_content/');
    响应.json({ 成功: true });
  } catch (错误) {
    响应.status(500).json({ 错误: 错误.message });
  }
  */
});

// 启动服务器
应用.listen(3000, () => {
  console.log('服务器运行在 http://localhost:3000');
});
```
#### 邮件操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/邮件/index.js
- 功能: 基于nodemailer的邮件发送操作中文API封装，提供完整的邮件发送、附件处理和模板功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持SMTP、Gmail、QQ邮箱、163邮箱、Outlook等多种邮件传输器
- 提供文本邮件、HTML邮件、带附件邮件、抄送邮件等多种发送方式
- 支持邮件模板、响应式HTML、表格邮件等高级功能
- 集成错误处理和依赖检查机制

**命令总数：27个**

**传输器创建函数** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建SMTP传输器 | 配置 | Object | 创建SMTP邮件传输器 | Object |
| 创建Gmail传输器 | 用户名, 密码, 额外配置 = {} | string, string, Object | 创建Gmail邮件传输器 | Object |
| 创建QQ邮箱传输器 | 用户名, 授权码, 额外配置 = {} | string, string, Object | 创建QQ邮件传输器 | Object |
| 创建163邮箱传输器 | 用户名, 授权码, 额外配置 = {} | string, string, Object | 创建163邮箱传输器 | Object |
| 创建Outlook传输器 | 用户名, 密码, 额外配置 = {} | string, string, Object | 创建Outlook邮件传输器 | Object |
| 测试传输器 | 传输器 | Object | 测试邮件传输器配置 | Promise<boolean> |

**邮件发送函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 发送文本邮件 | 传输器, 发件人, 收件人, 主题, 内容, 额外选项 = {} | Object, string, string\|Array, string, string, Object | 发送基本文本邮件 | Promise<Object> |
| 发送HTML邮件 | 传输器, 发件人, 收件人, 主题, HTML内容, 文本替代 = '', 额外选项 = {} | Object, string, string\|Array, string, string, string, Object | 发送HTML格式邮件 | Promise<Object> |
| 发送带附件邮件 | 传输器, 发件人, 收件人, 主题, 内容, 附件列表, 额外选项 = {} | Object, string, string\|Array, string, string\|Object, Array, Object | 发送带附件的邮件 | Promise<Object> |
| 发送抄送邮件 | 传输器, 发件人, 收件人, 主题, 内容, 抄送人 = [], 密送人 = [], 额外选项 = {} | Object, string, string\|Array, string, string\|Object, string\|Array, string\|Array, Object | 发送带抄送和密送的邮件 | Promise<Object> |
| 发送批量邮件 | 传输器, 邮件列表, 通用选项 = {} | Object, Array, Object | 批量发送多封邮件 | Promise<Array> |

**附件处理函数** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 添加文件附件 | 文件路径, 文件名, 额外选项 = {} | string, string, Object | 添加文件作为附件 | Object |
| 添加缓冲区附件 | 缓冲区, 文件名, 额外选项 = {} | Buffer, string, Object | 添加缓冲区数据作为附件 | Object |
| 添加URL附件 | URL, 文件名, 额外选项 = {} | string, string, Object | 添加URL指向的内容作为附件 | Object |
| 添加嵌入图片 | 文件路径, 图片ID, 额外选项 = {} | string, string, Object | 添加可嵌入HTML的图片 | Object |

**邮件模板函数** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建邮件模板 | 模板内容, 数据 | string, Object | 创建简单的变量替换邮件模板 | string |
| 创建响应式HTML模板 | 标题, 内容, 页脚 = '此邮件由系统自动发送，请不要直接回复' | string, string, string | 创建响应式HTML邮件模板 | string |
| 创建确认邮件模板 | 用户名, 确认链接, 操作类型 = '账户验证' | string, string, string | 创建确认操作邮件模板 | string |
| 创建密码重置邮件 | 用户名, 重置链接 | string, string | 创建密码重置邮件模板 | string |
| 创建表格邮件 | 标题, 表头, 数据行, 样式选项 = {} | string, Array, Array, Object | 创建表格格式邮件 | string |

**邮件配置函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置邮件优先级 | 邮件选项, 优先级 = 'normal' | Object, string | 设置邮件优先级 | Object |
| 关闭传输器 | 传输器 | Object | 关闭邮件传输器连接池 | Promise<void> |

**获取原始库函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始Nodemailer | 无 | 无 | 获取原始nodemailer库引用 | Object |

**依赖检查函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 验证Nodemailer库 | 无 | 无 | 验证nodemailer库是否已安装 | boolean |

**工具函数** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 验证Nodemailer库 | 无 | 无 | 验证nodemailer库是否已安装 | boolean |
| 设置邮件优先级 | 邮件选项, 优先级 = 'normal' | Object, string | 设置邮件优先级 | Object |
| 关闭传输器 | 传输器 | Object | 关闭邮件传输器连接池 | Promise<void> |

**使用示例**

**CommonJS模块导入:**
```javascript
const 邮件 = require('./zh/后端/邮件/index.js');
```

**基本邮件发送示例:**
```javascript
async function 发送基本邮件() {
  try {
    // 创建QQ邮箱传输器
    const 传输器 = 邮件.创建QQ邮箱传输器(
      'your-email@qq.com',  // 用户名
      'your-auth-code'      // 授权码
    );

    // 测试传输器配置
    const 测试成功 = await 邮件.测试传输器(传输器);
    if (测试成功) {
      console.log('传输器配置正确');
    } else {
      console.error('传输器配置错误');
      return;
    }

    // 发送文本邮件
    const 发送结果 = await 邮件.发送文本邮件(
      传输器,
      'your-email@qq.com',        // 发件人
      'recipient@example.com',    // 收件人
      '测试邮件',                 // 主题
      '这是一封测试邮件的内容。',  // 内容
      { cc: 'cc@example.com' }    // 额外选项（抄送）
    );

    console.log('邮件发送成功:', 发送结果.messageId);

    // 关闭传输器
    await 邮件.关闭传输器(传输器);
  } catch (错误) {
    console.error('发送邮件失败:', 错误.message);
  }
}

// 执行发送
发送基本邮件();
```

**HTML邮件和附件发送示例:**
```javascript
async function 发送HTML和附件邮件() {
  try {
    const 传输器 = 邮件.创建SMTP传输器({
      host: 'smtp.example.com',
      port: 587,
      secure: false,
      auth: {
        user: 'your-email@example.com',
        pass: 'your-password'
      }
    });

    // 创建HTML内容
    const HTML内容 = `
      <h1>欢迎使用我们的服务</h1>
      <p>尊敬的用户，</p>
      <p>感谢您的注册！请点击以下链接完成账户验证：</p>
      <a href="https://example.com/verify?id=123">验证账户</a>
      <p>如有任何问题，请随时联系我们。</p>
      <p>祝好，<br>客服团队</p>
    `;

    // 准备附件
    const 附件 = [
      邮件.添加文件附件('./document.pdf', '用户手册.pdf'),
      邮件.添加缓冲区附件(Buffer.from('测试数据'), '测试.txt'),
      邮件.添加URL附件('https://example.com/image.jpg', '产品图片.jpg')
    ];

    // 发送带附件的HTML邮件
    const 结果 = await 邮件.发送带附件邮件(
      传输器,
      'your-email@example.com',
      'recipient@example.com',
      '欢迎注册 - 请验证您的账户',
      { html: HTML内容 },
      附件
    );

    console.log('带附件的HTML邮件发送成功:', 结果.messageId);
    await 邮件.关闭传输器(传输器);
  } catch (错误) {
    console.error('发送HTML邮件失败:', 错误.message);
  }
}
```

**邮件模板使用示例:**
```javascript
async function 使用邮件模板() {
  try {
    const 传输器 = 邮件.创建Gmail传输器(
      'your-email@gmail.com',
      'your-app-password'
    );

    // 使用简单模板
    const 简单模板 = '亲爱的{用户名}，您好！您的验证码是{验证码}，有效期为{有效期}分钟。';
    const 渲染后内容 = 邮件.创建邮件模板(简单模板, {
      用户名: '张三',
      验证码: '123456',
      有效期: 30
    });

    // 创建响应式HTML邮件
    const 响应式邮件 = 邮件.创建响应式HTML模板(
      '账户安全提醒',
      `<p>${渲染后内容}</p>\n<p>请不要将验证码泄露给他人。</p>`,
      '© 2023 示例公司 - 安全中心'
    );

    // 发送模板邮件
    await 邮件.发送HTML邮件(
      传输器,
      'your-email@gmail.com',
      'user@example.com',
      '您的安全验证码',
      响应式邮件,
      渲染后内容 // 纯文本替代
    );

    // 创建确认邮件
    const 确认邮件 = 邮件.创建确认邮件模板(
      '李四',
      'https://example.com/confirm?id=789',
      '邮箱验证'
    );

    await 邮件.发送HTML邮件(
      传输器,
      'your-email@gmail.com',
      'user2@example.com',
      '请验证您的邮箱地址',
      确认邮件
    );

    // 创建表格邮件
    const 表格邮件 = 邮件.创建表格邮件(
      '月度账单',
      ['日期', '描述', '金额'],
      [
        ['2023-01-10', '会员订阅', '¥39.99'],
        ['2023-01-15', '产品购买', '¥159.00'],
        ['2023-01-20', '服务费', '¥19.99']
      ],
      { 表头背景色: '#4CAF50', 表格边框色: '#ddd' }
    );

    await 邮件.发送HTML邮件(
      传输器,
      'your-email@gmail.com',
      'user3@example.com',
      '您的月度账单已生成',
      表格邮件
    );

    console.log('所有模板邮件发送成功');
    await 邮件.关闭传输器(传输器);
  } catch (错误) {
    console.error('使用模板发送邮件失败:', 错误.message);
  }
}
```

**批量邮件发送示例:**
```javascript
async function 批量发送邮件() {
  try {
    const 传输器 = 邮件.创建163邮箱传输器(
      'your-email@163.com',
      'your-auth-code'
    );

    // 准备批量邮件列表
    const 批量邮件 = [
      {
        from: 'your-email@163.com',
        to: 'user1@example.com',
        subject: '批量邮件1',
        text: '这是第一封批量发送的邮件。'
      },
      {
        from: 'your-email@163.com',
        to: 'user2@example.com',
        subject: '批量邮件2',
        text: '这是第二封批量发送的邮件。'
      },
      {
        from: 'your-email@163.com',
        to: 'user3@example.com',
        subject: '批量邮件3',
        html: '<h2>HTML邮件</h2><p>这是一封HTML格式的批量邮件。</p>'
      }
    ];

    // 设置通用选项
    const 通用选项 = {
      priority: 'normal',
      attachments: [
        邮件.添加文本附件('这是通用附件内容', '通用附件.txt')
      ]
    };

    // 批量发送
    const 所有结果 = await 邮件.发送批量邮件(传输器, 批量邮件, 通用选项);

    // 处理结果
    所有结果.forEach((结果, 索引) => {
      if (结果.成功) {
        console.log(`邮件${索引 + 1}发送成功:`, 结果.结果.messageId);
      } else {
        console.error(`邮件${索引 + 1}发送失败:`, 结果.错误);
      }
    });

    await 邮件.关闭传输器(传输器);
  } catch (错误) {
    console.error('批量发送邮件失败:', 错误.message);
  }
}
```

**Express服务器集成示例:**
```javascript
const express = require('express');
const 应用 = express();
应用.use(express.json());

const 邮件 = require('./zh/后端/邮件/index.js');

// 全局邮件传输器配置
let 邮件传输器;

应用.post('/api/send-email', async (请求, 响应) => {
  try {
    const { 收件人, 主题, 内容, 类型 = 'text' } = 请求.body;

    // 懒加载传输器
    if (!邮件传输器) {
      邮件传输器 = 邮件.创建SMTP传输器({
        host: process.env.SMTP_HOST,
        port: process.env.SMTP_PORT,
        secure: process.env.SMTP_SECURE === 'true',
        auth: {
          user: process.env.SMTP_USER,
          pass: process.env.SMTP_PASS
        }
      });
    }

    let 结果;
    if (类型 === 'html') {
      结果 = await 邮件.发送HTML邮件(
        邮件传输器,
        process.env.SMTP_USER,
        收件人,
        主题,
        内容,
        内容.replace(/<[^>]*>/g, '') // 简单的HTML转文本
      );
    } else {
      结果 = await 邮件.发送文本邮件(
        邮件传输器,
        process.env.SMTP_USER,
        收件人,
        主题,
        内容
      );
    }

    响应.status(200).json({
      成功: true,
      messageId: 结果.messageId
    });
  } catch (错误) {
    响应.status(500).json({
      成功: false,
      错误: 错误.message
    });
  }
});

// 用户注册后发送确认邮件
应用.post('/api/register', async (请求, 响应) => {
  try {
    // 这里应该先处理用户注册逻辑
    const { 用户名, 邮箱 } = 请求.body;
    const 用户ID = '生成的用户ID';
    const 确认链接 = `https://example.com/verify?userId=${用户ID}`;

    // 创建确认邮件
    const 确认邮件内容 = 邮件.创建确认邮件模板(用户名, 确认链接);

    // 发送确认邮件
    await 邮件.发送HTML邮件(
      邮件传输器,
      process.env.SMTP_USER,
      邮箱,
      '请确认您的账户',
      确认邮件内容
    );

    响应.status(201).json({
      成功: true,
      消息: '注册成功，请查收邮件确认您的账户'
    });
  } catch (错误) {
    响应.status(500).json({
      成功: false,
      错误: 错误.message
    });
  }
});

// 应用启动前初始化邮件传输器
async function 初始化邮件服务() {
  try {
    邮件传输器 = 邮件.创建SMTP传输器({
      host: process.env.SMTP_HOST || 'smtp.example.com',
      port: process.env.SMTP_PORT || 587,
      secure: process.env.SMTP_SECURE === 'true',
      auth: {
        user: process.env.SMTP_USER || 'default@example.com',
        pass: process.env.SMTP_PASS || 'password'
      }
    });

    const 测试成功 = await 邮件.测试传输器(邮件传输器);
    console.log('邮件服务初始化:', 测试成功 ? '成功' : '失败');
    return 测试成功;
  } catch (错误) {
    console.error('邮件服务初始化失败:', 错误.message);
    return false;
  }
}

// 启动服务器
const 端口 = process.env.PORT || 3000;
初始化邮件服务().then(() => {
  应用.listen(端口, () => {
    console.log(`服务器运行在 http://localhost:${端口}`);
  });
});
```
#### CSV操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/CSV/index.js
- 功能: 提供CSV文件读写、解析和处理的中文API封装，支持文件操作、数据转换和高级数据处理功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持CSV文件读写、字符串解析和生成
- 提供JSON与CSV之间的双向转换功能
- 支持CSV数据过滤、排序、去重等高级处理
- 集成错误处理和文件验证机制

**命令总数：14个**

**核心功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 读取CSV文件 | 文件路径, 选项 = {} | string, Object | 从CSV文件读取数据 | Array |
| 写入CSV文件 | 文件路径, 数据, 选项 = {} | string, Array, Object | 将数据写入CSV文件 | 无 |
| 解析CSV | csv字符串, 选项 = {} | string, Object | 解析CSV格式的字符串 | Array |
| 生成CSV | 数据, 选项 = {} | Array, Object | 生成CSV格式的字符串 | string |

**转换功能** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| JSON转CSV | json数据, 选项 = {} | Array, Object | 将JSON对象数组转换为CSV字符串 | string |
| CSV转JSON | csv字符串, 选项 = {} | string, Object | 将CSV字符串转换为JSON对象数组 | Array |

**文件操作** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取CSV文件信息 | 文件路径 | string | 获取CSV文件的基本信息 | Object |
| 合并CSV文件 | 文件路径列表, 输出路径, 选项 = {} | Array, string, Object | 合并多个CSV文件 | 无 |

**数据处理** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 验证CSV格式 | csv字符串 | string | 验证CSV字符串格式是否有效 | boolean |
| 过滤CSV数据 | csv数据, 过滤函数 | Array, Function | 根据条件过滤CSV数据 | Array |
| 排序CSV数据 | csv数据, 列索引或标题, 降序 = false | Array, number\|string, boolean | 对CSV数据进行排序 | Array |
| 去重CSV数据 | csv数据, 比较列 = [] | Array, Array | 去除CSV数据中的重复行 | Array |

**常量定义** (1个)

| 常量名 | 类型 | 功能描述 | 值 |
|-------|-----|---------|-----|
| 分隔符 | Object | 预定义的CSV分隔符常量 | { 逗号: ',', 分号: ';', 制表符: '\t', 竖线: '|' } |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个CSV模块
const CSV = require('./zh/后端/CSV/index.js');
```

**基本文件操作示例:**
```javascript
const CSV = require('./zh/后端/CSV/index.js');

// 读取CSV文件
const 数据 = CSV.读取CSV文件('./data.csv', {
  编码: 'utf8',
  分隔符: CSV.分隔符.逗号
});
console.log('读取的数据:', 数据);

// 写入CSV文件
const 新数据 = [
  ['姓名', '年龄', '城市'],
  ['张三', '25', '北京'],
  ['李四', '30', '上海']
];
CSV.写入CSV文件('./output.csv', 新数据);

// 获取文件信息
const 文件信息 = CSV.获取CSV文件信息('./data.csv');
console.log('文件信息:', 文件信息);

// 合并多个CSV文件
CSV.合并CSV文件(['file1.csv', 'file2.csv'], 'merged.csv');
```

**CSV与JSON转换示例:**
```javascript
const CSV = require('./zh/后端/CSV/index.js');

// JSON转CSV
const json数据 = [
  { 姓名: '张三', 年龄: 25, 城市: '北京' },
  { 姓名: '李四', 年龄: 30, 城市: '上海' },
  { 姓名: '王五', 年龄: 28, 城市: '广州' }
];
const csv字符串 = CSV.JSON转CSV(json数据);
console.log('JSON转CSV结果:', csv字符串);

// CSV转JSON
const csv数据 = '姓名,年龄,城市\n张三,25,北京\n李四,30,上海';
const json结果 = CSV.CSV转JSON(csv数据);
console.log('CSV转JSON结果:', json结果);
```

**高级数据处理示例:**
```javascript
const CSV = require('./zh/后端/CSV/index.js');

// 读取数据
let csv数据 = CSV.读取CSV文件('./users.csv');

// 过滤数据（年龄大于25的用户）
const 过滤后的数据 = CSV.过滤CSV数据(csv数据, 行 => {
  return parseInt(行.年龄) > 25;
});

// 排序数据（按年龄降序）
const 排序后的数据 = CSV.排序CSV数据(过滤后的数据, '年龄', true);

// 去重数据
const 去重后的数据 = CSV.去重CSV数据(排序后的数据, [0]); // 根据姓名列去重

// 写入结果
CSV.写入CSV文件('./processed_users.csv', 去重后的数据);

// 验证CSV格式
const 格式有效 = CSV.验证CSV格式(csv字符串);
console.log('CSV格式是否有效:', 格式有效);
```

**自定义选项示例:**
```javascript
const CSV = require('./zh/后端/CSV/index.js');

// 自定义分隔符和编码
const 自定义读取选项 = {
  分隔符: CSV.分隔符.分号,
  编码: 'utf8',
  跳过标题行: false
};

const 自定义写入选项 = {
  分隔符: CSV.分隔符.制表符,
  编码: 'utf8',
  包含标题行: true,
  标题行: ['ID', '名称', '价格']
};

// 使用自定义选项读取和写入
const 数据 = CSV.读取CSV文件('./custom.csv', 自定义读取选项);
CSV.写入CSV文件('./output_custom.csv', 数据, 自定义写入选项);

// 直接操作CSV字符串
const 原始CSV = '产品\t价格\t库存\n手机\t2999\t50\n电脑\t5999\t20';
const 解析结果 = CSV.解析CSV(原始CSV, {
  分隔符: '\t'
});

const 生成结果 = CSV.生成CSV(解析结果, {
  分隔符: ',',
  引号: '"'
});
```

**Express服务器集成示例:**
```javascript
const express = require('express');
const multer = require('multer');
const CSV = require('./zh/后端/CSV/index.js');
const fs = require('fs');
const path = require('path');

const 应用 = express();
const 端口 = 3000;

// 配置中间件
应用.use(express.json());
应用.use(express.urlencoded({ extended: true }));

// 配置文件上传
const 存储 = multer.diskStorage({
  destination: (请求, 文件, 回调) => {
    回调(null, 'uploads/');
  },
  filename: (请求, 文件, 回调) => {
    回调(null, Date.now() + path.extname(file.originalname));
  }
});

const 上传 = multer({ 存储 });

// 确保uploads目录存在
if (!fs.existsSync('uploads')) {
  fs.mkdirSync('uploads');
}

// 路由：上传CSV文件并解析
应用.post('/api/upload-csv', 上传.single('文件'), (请求, 响应) => {
  try {
    const 文件路径 = 请求.file.path;
    const 数据 = CSV.读取CSV文件(文件路径);
    
    // 解析完成后删除临时文件
    fs.unlinkSync(文件路径);
    
    响应.status(200).json({
      成功: true,
      数据,
      行数: 数据.length,
      列数: 数据.length > 0 ? 数据[0].length : 0
    });
  } catch (错误) {
    响应.status(500).json({
      成功: false,
      错误: 错误.message
    });
  }
});

// 路由：将JSON数据转换为CSV并下载
应用.post('/api/export-csv', (请求, 响应) => {
  try {
    const { 数据, 文件名 } = 请求.body;
    
    if (!Array.isArray(数据)) {
      throw new Error('数据必须是数组格式');
    }
    
    const csv内容 = CSV.JSON转CSV(数据);
    const 临时文件 = `temp_${Date.now()}.csv`;
    
    // 写入临时文件
    CSV.写入CSV文件(临时文件, CSV.解析CSV(csv内容));
    
    // 发送文件给客户端
    响应.download(临时文件, 文件名 || '导出数据.csv', () => {
      // 下载完成后删除临时文件
      fs.unlinkSync(临时文件);
    });
  } catch (错误) {
    响应.status(500).json({
      成功: false,
      错误: 错误.message
    });
  }
});

// 启动服务器
应用.listen(端口, () => {
  console.log(`服务器运行在 http://localhost:${端口}`);
});
```
#### Express框架中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/Express/index.js
- 功能: 提供Express框架的中文API封装，支持路由、中间件、请求处理、响应处理、Cookie和Session管理等核心功能

**核心特性**
- 完整支持中文函数名和参数名，提高代码可读性
- 提供JSDoc参数提示，方便开发使用
- 支持所有Express核心功能的中文封装
- 包含路由管理、中间件配置、请求处理和响应生成
- 提供Cookie和Session完整管理功能
- 支持模板引擎配置和静态文件服务

**命令总数：48个**

**基础应用功能** (9个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建应用 | 无 | 无 | 创建一个新的Express应用实例 | Object |
| 启动服务器 | 应用, 端口, 回调函数 | Object, number\|string, Function | 监听指定端口启动服务器 | Object |
| 创建路由器 | 无 | 无 | 创建Express路由器实例 | Object |
| 使用中间件 | 应用, ...中间件 | Object, ...Function\|string | 使用中间件函数 | 无 |
| 静态文件服务 | 应用, 路径, 静态目录 | Object, string, string | 配置静态文件服务 | 无 |
| 解析JSON | 应用, 选项 | Object, Object | 解析JSON请求体 | 无 |
| 解析URL编码 | 应用, 选项 | Object, Object | 解析URL编码请求体 | 无 |
| 错误处理中间件 | 应用, 错误处理函数 | Object, Function | 配置错误处理中间件 | 无 |
| 获取原始Express | 无 | 无 | 获取Express原始模块 | Object |

**路由功能** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 监听GET请求 | 应用, 路径, ...处理函数 | Object, string, ...Function | 处理GET请求 | 无 |
| 监听POST请求 | 应用, 路径, ...处理函数 | Object, string, ...Function | 处理POST请求 | 无 |
| 监听PUT请求 | 应用, 路径, ...处理函数 | Object, string, ...Function | 处理PUT请求 | 无 |
| 监听DELETE请求 | 应用, 路径, ...处理函数 | Object, string, ...Function | 处理DELETE请求 | 无 |
| 监听所有请求 | 应用, 路径, ...处理函数 | Object, string, ...Function | 处理所有HTTP方法的请求 | 无 |

**视图与模板功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置模板引擎 | 应用, 引擎名称, 渲染函数 | Object, string, Function | 设置自定义模板引擎 | 无 |
| 设置视图引擎 | 应用, 引擎名称 | Object, string | 设置视图引擎 | 无 |
| 设置视图目录 | 应用, 目录路径 | Object, string | 设置视图文件目录 | 无 |
| 渲染视图 | 响应对象, 视图名称, 数据, 回调函数 | Object, string, Object, Function | 渲染视图模板 | 无 |

**响应处理功能** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 发送JSON | 响应对象, 数据 | Object, * | 发送JSON响应 | 无 |
| 发送文本 | 响应对象, 文本 | Object, string | 发送文本响应 | 无 |
| 发送文件 | 响应对象, 文件路径, 选项, 回调函数 | Object, string, Object, Function | 发送文件响应 | 无 |
| 设置状态码 | 响应对象, 状态码 | Object, number | 设置HTTP状态码 | Object |
| 重定向 | 响应对象, 状态码, url | Object, string\|number, string | 重定向请求 | 无 |
| 设置响应头 | 响应对象, 名称, 值 | Object, string, string | 设置响应头信息 | 无 |

**请求处理功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取请求参数 | 请求对象, 参数名 | Object, string | 获取URL路径参数 | string\|Object |
| 获取查询参数 | 请求对象, 参数名 | Object, string | 获取URL查询参数 | string |
| 获取请求体 | 请求对象, 字段名 | Object, string | 获取请求体数据 | * |
| 获取请求头 | 请求对象, 头名称 | Object, string | 获取请求头信息 | string |

**Cookie管理功能** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 配置Cookie解析器 | 应用, 密钥, 选项 | Object, string, Object | 配置Cookie解析中间件 | 无 |
| 设置Cookie | 响应对象, 名称, 值, 选项 | Object, string, string, Object | 设置Cookie | 无 |
| 获取Cookie | 请求对象, 名称 | Object, string | 获取Cookie值 | string |
| 获取签名Cookie | 请求对象, 名称 | Object, string | 获取已签名的Cookie值 | string |
| 清除Cookie | 响应对象, 名称, 选项 | Object, string, Object | 清除Cookie | 无 |

**Session管理功能** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 配置Session | 应用, 选项 | Object, Object | 配置Session中间件 | 无 |
| 设置Session数据 | 请求对象, 键, 值 | Object, string, * | 设置Session数据 | 无 |
| 获取Session数据 | 请求对象, 键 | Object, string | 获取Session数据 | * |
| 销毁Session | 请求对象, 回调函数 | Object, Function | 销毁Session | 无 |
| 重新生成Session | 请求对象, 回调函数 | Object, Function | 重新生成Session ID | 无 |
| 保存Session | 请求对象, 回调函数 | Object, Function | 保存Session | 无 |
| 触摸Session | 请求对象 | Object | 触摸Session（更新过期时间） | 无 |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个Express模块
const Express = require('./zh/后端/Express/index.js');
```

**基本服务器创建示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');

// 创建Express应用
const 应用 = Express.创建应用();

// 配置中间件
Express.使用中间件(应用, Express.解析JSON(应用, { limit: '1mb' }));
Express.使用中间件(应用, Express.解析URL编码(应用, { extended: true }));

// 设置静态文件服务
Express.静态文件服务(应用, '/public', './public');

// 定义路由
Express.监听GET请求(应用, '/', (请求, 响应) => {
  Express.发送文本(响应, 'Hello Express中文封装!');
});

Express.监听GET请求(应用, '/api/data', (请求, 响应) => {
  Express.发送JSON(响应, {
    消息: '成功',
    数据: [1, 2, 3, 4, 5]
  });
});

// 启动服务器
Express.启动服务器(应用, 3000, () => {
  console.log('服务器运行在 http://localhost:3000');
});
```

**路由与参数处理示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const 应用 = Express.创建应用();

// 配置解析中间件
Express.使用中间件(应用, Express.解析JSON(应用));
Express.使用中间件(应用, Express.解析URL编码(应用, { extended: true }));

// 路由参数示例
Express.监听GET请求(应用, '/user/:id', (请求, 响应) => {
  const 用户ID = Express.获取请求参数(请求, 'id');
  Express.发送JSON(响应, {
    用户ID: 用户ID,
    消息: `获取用户 ${用户ID} 的信息`
  });
});

// 查询参数示例
Express.监听GET请求(应用, '/search', (请求, 响应) => {
  const 关键词 = Express.获取查询参数(请求, 'q');
  const 页码 = Express.获取查询参数(请求, 'page') || '1';
  Express.发送JSON(响应, {
    关键词: 关键词,
    页码: 页码,
    结果: []
  });
});

// POST请求处理示例
Express.监听POST请求(应用, '/api/submit', (请求, 响应) => {
  const 用户名 = Express.获取请求体(请求, '用户名');
  const 邮箱 = Express.获取请求体(请求, '邮箱');
  
  Express.设置状态码(响应, 201);
  Express.发送JSON(响应, {
    成功: true,
    消息: '提交成功',
    数据: { 用户名, 邮箱 }
  });
});

Express.启动服务器(应用, 3000);
```

**Cookie和Session管理示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const 应用 = Express.创建应用();

// 配置中间件
Express.使用中间件(应用, Express.解析JSON(应用));

// 配置Cookie解析器
Express.配置Cookie解析器(应用, 'secret-key', { 
  maxAge: 3600000,
  httpOnly: true 
});

// 配置Session
Express.配置Session(应用, {
  secret: 'session-secret',
  resave: false,
  saveUninitialized: true,
  cookie: { secure: false } // 在生产环境中应该设置为true
});

// 使用Cookie的路由
Express.监听GET请求(应用, '/set-cookie', (请求, 响应) => {
  Express.设置Cookie(响应, '用户偏好', 'dark-theme', {
    maxAge: 3600000,
    httpOnly: true
  });
  Express.发送文本(响应, 'Cookie已设置');
});

Express.监听GET请求(应用, '/get-cookie', (请求, 响应) => {
  const 用户偏好 = Express.获取Cookie(请求, '用户偏好');
  Express.发送JSON(响应, {
    用户偏好: 用户偏好 || '默认偏好'
  });
});

// 使用Session的路由
Express.监听POST请求(应用, '/login', (请求, 响应) => {
  const 用户名 = Express.获取请求体(请求, '用户名');
  
  // 设置Session
  Express.设置Session数据(请求, '用户名', 用户名);
  Express.设置Session数据(请求, '登录时间', new Date().toISOString());
  
  Express.发送JSON(响应, {
    成功: true,
    消息: '登录成功'
  });
});

Express.监听GET请求(应用, '/profile', (请求, 响应) => {
  const 用户名 = Express.获取Session数据(请求, '用户名');
  
  if (!用户名) {
    Express.重定向(响应, '/login');
    return;
  }
  
  Express.发送JSON(响应, {
    用户名: 用户名,
    登录时间: Express.获取Session数据(请求, '登录时间')
  });
});

Express.监听GET请求(应用, '/logout', (请求, 响应) => {
  Express.销毁Session(请求, () => {
    Express.重定向(响应, '/login');
  });
});

Express.启动服务器(应用, 3000);
```

**模板引擎配置示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const path = require('path');
const 应用 = Express.创建应用();

// 设置视图目录
Express.设置视图目录(应用, path.join(__dirname, 'views'));

// 设置视图引擎（例如使用ejs）
Express.设置视图引擎(应用, 'ejs');

// 渲染视图的路由
Express.监听GET请求(应用, '/', (请求, 响应) => {
  Express.渲染视图(响应, 'index', {
    标题: 'Express中文封装示例',
    消息: '欢迎使用模板引擎',
    用户列表: [
      { 姓名: '张三', 年龄: 25 },
      { 姓名: '李四', 年龄: 30 },
      { 姓名: '王五', 年龄: 28 }
    ]
  });
});

// 自定义模板引擎示例（假设我们有一个简单的模板函数）
function 简单模板引擎(文件路径, 数据, 回调) {
  // 这里应该实现模板解析逻辑
  // 为了示例简化，我们只返回一个简单的HTML
  const html = `
    <!DOCTYPE html>
    <html>
    <head><title>${数据.标题 || '默认标题'}</title></head>
    <body>
      <h1>${数据.消息 || '无消息'}</h1>
    </body>
    </html>
  `;
  callback(null, html);
}

// 注册自定义模板引擎
Express.设置模板引擎(应用, 'simple', 简单模板引擎);

// 使用自定义模板引擎
Express.监听GET请求(应用, '/custom-template', (请求, 响应) => {
  Express.渲染视图(响应, 'custom.simple', {
    标题: '自定义模板',
    消息: '这是自定义模板引擎渲染的内容'
  });
});

Express.启动服务器(应用, 3000);
```

**中间件与错误处理示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const 应用 = Express.创建应用();

// 自定义日志中间件
function 日志中间件(请求, 响应, 下一个) {
  console.log(`${请求.method} ${请求.url} - ${new Date().toISOString()}`);
  下一个();
}

// 认证中间件
function 认证中间件(请求, 响应, 下一个) {
  const 令牌 = Express.获取请求头(请求, 'Authorization');
  
  if (!令牌) {
    Express.设置状态码(响应, 401);
    Express.发送JSON(响应, {
      错误: '未授权，请提供令牌'
    });
    return;
  }
  
  // 这里应该验证令牌
  // 为了示例简化，我们只检查令牌是否存在
  Express.设置Session数据(请求, '用户', { 令牌 });
  下一个();
}

// 应用中间件
Express.使用中间件(应用, 日志中间件);
Express.使用中间件(应用, Express.解析JSON(应用));

// 受保护的路由
Express.使用中间件(应用, '/api/protected', 认证中间件);

Express.监听GET请求(应用, '/api/protected/data', (请求, 响应) => {
  Express.发送JSON(响应, {
    消息: '这是受保护的数据',
    时间: new Date().toISOString()
  });
});

// 错误处理中间件
Express.错误处理中间件(应用, (错误, 请求, 响应, 下一个) => {
  console.error('错误:', 错误);
  
  Express.设置状态码(响应, 错误.status || 500);
  Express.发送JSON(响应, {
    错误: {
      消息: 错误.message,
      状态: 错误.status || 500
    }
  });
});

// 404处理
Express.监听所有请求(应用, '*', (请求, 响应) => {
  Express.设置状态码(响应, 404);
  Express.发送JSON(响应, {
    错误: '请求的资源不存在'
  });
});

Express.启动服务器(应用, 3000);
```
#### PDF操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/PDF/index.js
- 功能: 提供PDF文档创建、编辑、读取和转换的中文API封装，基于pdfmake、pdf-parse和hummus等库

**核心特性**
- 完整支持PDF文档的创建、生成和保存
- 提供丰富的PDF内容元素创建功能（文本、表格、图片、列表等）
- 支持PDF文档读取、解析和内容提取
- 提供PDF操作功能（合并、分割、添加水印、页码等）
- 支持PDF转换功能（转图片、转HTML、转文本等）
- 提供完整的样式系统和文档结构管理

**命令总数：75个**

**核心生成功能** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建PDF文档定义 | 内容, 选项 | Object\|Array, Object | 创建PDF文档定义对象 | Object |
| 生成并保存PDF | 文档定义, 文件路径, 字体选项 | Object, string, Object | 生成PDF并保存到文件 | Promise<void> |
| 生成PDFBuffer | 文档定义, 字体选项 | Object, Object | 生成PDF并获取Buffer | Promise<Buffer> |
| 生成PDFBase64 | 文档定义, 字体选项 | Object, Object | 生成PDF并获取Base64字符串 | Promise<string> |
| 流式输出PDF到响应 | 文档定义, 响应对象, 字体选项 | Object, Object, Object | 流式输出PDF到HTTP响应 | void |
| 流式输出PDF到流 | 文档定义, 可写流, 字体选项 | Object, Object, Object | 流式输出PDF到可写流 | void |

**文本和段落元素** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建文本元素 | 文本内容, 样式选项 | string\|Array, Object | 创建文本元素 | Object\|Array |
| 创建段落 | 段落内容, 样式选项 | Array, Object | 创建段落元素 | Object |
| 创建标题 | 标题文本, 级别, 样式选项 | string, number, Object | 创建标题元素 | Object |

**媒体和图形元素** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建图片元素 | 图片数据, 样式选项 | string\|Buffer, Object | 创建图片元素 | Object |
| 创建二维码 | 二维码内容, 样式选项 | string, Object | 创建二维码元素 | Object |
| 创建条形码 | 条形码内容, 样式选项 | string, Object | 创建条形码元素 | Object |
| 创建分割线 | 样式选项 | Object | 创建分割线元素 | Object |
| 创建水印 | 水印文本, 样式选项 | string, Object | 创建水印元素 | Object |

**图形绘制元素** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建矩形 | 样式选项 | Object | 创建矩形图形元素 | Object |
| 创建圆形 | 样式选项 | Object | 创建圆形图形元素 | Object |
| 创建线条 | 样式选项 | Object | 创建线条图形元素 | Object |
| 创建多边形 | 点坐标数组, 样式选项 | Array, Object | 创建多边形图形元素 | Object |

**表格相关** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建表格 | 表格数据, 样式选项 | Array, Object | 创建表格元素 | Object |
| 创建表格布局 | 布局选项 | Object | 创建高级表格布局 | Object |
| 创建表格样式 | 样式属性 | Object | 创建表格样式对象 | Object |

**列表和列** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建列表 | 列表项, 样式选项 | Array, Object | 创建列表元素 | Object |
| 创建列 | 列内容, 样式选项 | Array, Object | 创建列元素 | Object |

**导航和链接** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建链接 | 链接文本, 链接URL, 样式选项 | string, string, Object | 创建PDF链接元素 | Object |
| 创建页面引用 | 链接文本, 页码, 样式选项 | string, number, Object | 创建页面引用链接 | Object |

**文档结构** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建复杂文档 | 文档配置 | Object | 创建包含多种元素的复杂文档 | Object |
| 创建目录 | 样式选项 | Object | 创建目录元素 | Object |

**样式系统** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建文本样式 | 样式属性 | Object | 创建文本样式对象 | Object |
| 创建样式系统 | 样式定义 | Object | 创建样式系统对象 | Object |
| 创建段落样式 | 段落样式定义 | Object | 创建段落样式系统 | Object |

**页面布局** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建页面边距 | 左边距, 上边距, 右边距, 下边距 | number, number, number, number | 创建页面边距配置 | Array |
| 创建页眉 | 页眉内容, 样式选项 | string\|Object\|Function, Object | 创建页眉 | Object\|Function |
| 创建页脚 | 页脚内容, 样式选项 | string\|Object\|Function, Object | 创建页脚 | Object\|Function |
| 创建页码函数 | 样式选项 | Object | 创建页码函数 | Function |

**高级功能** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 注册自定义字体 | 字体配置 | Object | 注册自定义字体 | Object |
| 创建绝对定位元素 | 元素, x, y, 样式选项 | Object\|Array, number, number, Object | 创建绝对定位元素 | Object\|Array |
| 创建页面断开控制 | 判断函数 | Function | 创建页面断开控制函数 | Function |
| 创建页面事件 | 事件处理 | Object | 创建页面事件处理函数 | Object |
| 创建字体定义 | 字体选项 | Object | 创建字体定义对象 | Object |

**PDF读取与解析功能** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 读取PDF文件 | 文件路径 | string | 读取PDF文件 | Promise<Object> |
| 从Buffer读取PDF | 缓冲区 | Buffer | 从Buffer读取PDF | Promise<Object> |
| 解析PDF文本内容 | PDF数据 | string\|Buffer | 解析PDF文本内容 | Promise<string> |
| 提取PDF页面 | 源文件路径, 目标文件路径, 页面范围 | string, string, Array | 提取PDF页面 | Promise<void> |
| 提取PDF图片 | PDF数据, 输出目录 | string\|Buffer, string | 提取PDF图片 | Promise<Array> |
| 获取PDF页面数 | PDF数据 | string\|Buffer | 获取PDF页面数 | Promise<number> |
| 获取PDF元数据 | PDF数据 | string\|Buffer | 获取PDF元数据 | Promise<Object> |

**PDF操作功能** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 合并PDF文档 | 文件路径数组, 输出文件路径 | Array, string | 合并PDF文档 | Promise<void> |
| 分割PDF文档 | 源文件路径, 输出目录, 分割选项 | string, string, Object | 分割PDF文档 | Promise<Array> |
| 添加PDF水印 | 源文件路径, 输出文件路径, 水印文本, 水印选项 | string, string, string, Object | 添加PDF水印 | Promise<void> |
| 添加PDF页码 | 源文件路径, 输出文件路径, 页码选项 | string, string, Object | 添加PDF页码 | Promise<void> |
| PDF加密 | 源文件路径, 输出文件路径, 用户密码, 所有者密码, 权限选项 | string, string, string, string, Object | PDF加密 | Promise<void> |
| PDF解密 | 源文件路径, 输出文件路径, 密码 | string, string, string | PDF解密 | Promise<void> |
| 旋转PDF页面 | 源文件路径, 输出文件路径, 角度, 页面范围 | string, string, number, Array | 旋转PDF页面 | Promise<void> |
| 压缩PDF文件 | 源文件路径, 输出文件路径, 压缩选项 | string, string, Object | 压缩PDF文件 | Promise<void> |

**PDF转换功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| PDF转图片 | 源文件路径, 输出目录, 转换选项 | string, string, Object | PDF转图片 | Promise<Array> |
| PDF转HTML | 源文件路径, 输出文件路径 | string, string | PDF转HTML | Promise<void> |
| PDF转文本 | PDF数据 | string\|Buffer | PDF转文本 | Promise<string> |
| 比较PDF文档 | 文件路径1, 文件路径2 | string, string | 比较PDF文档 | Promise<Object> |

**常量** (5个)

| 常量名 | 类型 | 描述 | 值 |
|-------|-----|------|-----|
| 页面尺寸 | Object | PDF页面尺寸常量 | {A3, A4, A5, LEGAL, LETTER, TABLOID} |
| 页面方向 | Object | PDF页面方向常量 | {纵向: 'portrait', 横向: 'landscape'} |
| 对齐方式 | Object | 文本对齐方式常量 | {左对齐: 'left', 右对齐: 'right', 居中: 'center', 两端对齐: 'justify'} |
| 列表类型 | Object | 列表类型常量 | {无序列表: 'unordered', 有序列表: 'ordered'} |
| 条形码类型 | Object | 条形码类型常量 | {EAN13, EAN8, UPCA, UPCE, CODE39, CODE128} |

**获取原始库** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始pdfmake | 无 | 无 | 获取pdfmake原始模块 | Object |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个PDF模块
const PDF = require('./zh/后端/PDF/index.js');
```

**基本PDF生成示例:**
```javascript
const PDF = require('./zh/后端/PDF/index.js');

// 创建PDF文档定义
const 文档定义 = PDF.创建PDF文档定义([
  PDF.创建标题('PDF生成示例', 1),
  PDF.创建文本元素('这是一个使用中文API生成的PDF文档示例。'),
  PDF.创建段落([
    '这是第一个段落。',
    '这是第二个段落。'
  ]),
  PDF.创建表格([
    ['姓名', '年龄', '城市'],
    ['张三', '25', '北京'],
    ['李四', '30', '上海'],
    ['王五', '28', '广州']
  ]),
  PDF.创建列表([
    '项目一',
    '项目二',
    '项目三'
  ], { type: PDF.列表类型.无序列表 })
], {
  页面尺寸: PDF.页面尺寸.A4,
  页面方向: PDF.页面方向.纵向,
  页面边距: PDF.创建页面边距(40, 60, 40, 60)
});

// 生成并保存PDF
async function 生成PDF() {
  try {
    await PDF.生成并保存PDF(文档定义, './示例文档.pdf');
    console.log('PDF生成成功！');
  } catch (错误) {
    console.error('PDF生成失败:', 错误);
  }
}

生成PDF();
```

**复杂文档创建示例:**
```javascript
const PDF = require('./zh/后端/PDF/index.js');

// 创建复杂文档配置
const 文档配置 = {
  标题: '公司年度报告',
  副标题: '2023年业绩总结',
  作者: '张三',
  日期: '2023年12月31日',
  摘要: '本报告总结了公司2023年度的业绩情况，包括财务数据、业务发展和未来规划。',
  包含目录: true,
  段落: [
    '2023年是公司发展的重要一年。在这一年里，我们实现了业务的快速增长。',
    '全年营收达到10亿元，同比增长25%。净利润达到2亿元，同比增长30%。',
    '在市场拓展方面，我们新增了5个海外市场，国内市场份额提升至15%。'
  ],
  表格: {
    表格标题: '季度业绩数据',
    表格数据: [
      ['季度', '营收(万元)', '利润(万元)', '同比增长'],
      ['Q1', '20000', '3500', '15%'],
      ['Q2', '22000', '3800', '18%'],
      ['Q3', '25000', '4200', '22%'],
      ['Q4', '33000', '8500', '35%']
    ],
    表格样式: {
      widths: ['auto', '*', '*', '*'],
      tableLayout: PDF.创建表格布局()
    }
  },
  列表: {
    列表标题: '下一年工作重点',
    列表项: [
      '扩大海外市场份额',
      '加强产品研发投入',
      '提升客户服务质量',
      '优化供应链管理'
    ],
    列表样式: { type: PDF.列表类型.有序列表 }
  },
  页面尺寸: PDF.页面尺寸.A4,
  页面边距: PDF.创建页面边距(40, 70, 40, 60),
  样式: PDF.创建样式系统()
};

// 创建复杂文档
const 复杂文档定义 = PDF.创建复杂文档(文档配置);

// 生成PDF
async function 生成年度报告() {
  try {
    await PDF.生成并保存PDF(复杂文档定义, './年度报告.pdf');
    console.log('年度报告生成成功！');
  } catch (错误) {
    console.error('年度报告生成失败:', 错误);
  }
}

生成年度报告();
```

**PDF读取和解析示例:**
```javascript
const PDF = require('./zh/后端/PDF/index.js');

// 读取PDF文件
async function 读取PDF() {
  try {
    // 读取PDF文件
    const PDF文档 = await PDF.读取PDF文件('./示例文档.pdf');
    console.log('PDF信息:', PDF文档.info);
    console.log('页数:', PDF文档.numpages);
    
    // 解析PDF文本内容
    const 文本内容 = await PDF.解析PDF文本内容('./示例文档.pdf');
    console.log('文本内容长度:', 文本内容.length);
    console.log('文本内容:', 文本内容.substring(0, 200) + '...');
    
    // 获取PDF页面数
    const 页面数 = await PDF.获取PDF页面数('./示例文档.pdf');
    console.log('确认页面数:', 页面数);
    
    // 获取PDF元数据
    const 元数据 = await PDF.获取PDF元数据('./示例文档.pdf');
    console.log('元数据:', 元数据);
    
  } catch (错误) {
    console.error('PDF读取失败:', 错误);
  }
}

读取PDF();
```

**PDF操作示例:**
```javascript
const PDF = require('./zh/后端/PDF/index.js');

// PDF操作函数
async function 操作PDF() {
  try {
    // 提取PDF页面（提取第1页和第3页）
    await PDF.提取PDF页面('./示例文档.pdf', './提取页面.pdf', [1, 3]);
    console.log('PDF页面提取成功！');
    
    // 添加PDF水印
    await PDF.添加PDF水印('./示例文档.pdf', './带水印.pdf', '示例水印', {
      颜色: 0x999999
    });
    console.log('PDF水印添加成功！');
    
    // 添加PDF页码
    await PDF.添加PDF页码('./示例文档.pdf', './带页码.pdf', {
      起始页码: 1,
      格式: '第 ${page} 页，共 ${total} 页',
      字号: 10,
      垂直位置: 20
    });
    console.log('PDF页码添加成功！');
    
    // 合并PDF文档
    await PDF.合并PDF文档(['./文档1.pdf', './文档2.pdf'], './合并文档.pdf');
    console.log('PDF文档合并成功！');
    
    // 分割PDF文档
    const 分割文件 = await PDF.分割PDF文档('./示例文档.pdf', './分割目录');
    console.log('PDF文档分割成功！', 分割文件);
    
    // 旋转PDF页面
    await PDF.旋转PDF页面('./示例文档.pdf', './旋转页面.pdf', 90, [1]);
    console.log('PDF页面旋转成功！');
    
  } catch (错误) {
    console.error('PDF操作失败:', 错误);
  }
}

操作PDF();
```

**Web服务器PDF生成示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const PDF = require('./zh/后端/PDF/index.js');

const 应用 = Express.创建应用();

// 配置中间件
Express.使用中间件(应用, Express.解析JSON(应用));

// 生成PDF并下载的路由
Express.监听GET请求(应用, '/api/generate-pdf', (请求, 响应) => {
  try {
    // 创建PDF文档定义
    const 文档定义 = PDF.创建PDF文档定义([
      PDF.创建标题('API生成的PDF', 1),
      PDF.创建文本元素('这是通过Web API动态生成的PDF文档。'),
      PDF.创建文本元素(`生成时间: ${new Date().toLocaleString('zh-CN')}`),
      PDF.创建表格([
        ['参数', '值'],
        ['用户ID', Express.获取查询参数(请求, 'userId') || '未提供'],
        ['类型', Express.获取查询参数(请求, 'type') || '默认']
      ])
    ]);
    
    // 设置响应头
    Express.设置响应头(响应, 'Content-Type', 'application/pdf');
    Express.设置响应头(响应, 'Content-Disposition', 'attachment; filename=generated.pdf');
    
    // 流式输出PDF到响应
    PDF.流式输出PDF到响应(文档定义, 响应);
    
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: 'PDF生成失败' });
  }
});

// 启动服务器
Express.启动服务器(应用, 3000, () => {
  console.log('PDF生成服务器运行在 http://localhost:3000');
});
```

**高级图形和样式示例:**
```javascript
const PDF = require('./zh/后端/PDF/index.js');

// 创建包含图形和复杂样式的文档
const 图形文档定义 = PDF.创建PDF文档定义([
  PDF.创建标题('高级图形和样式示例', 1),
  
  // 创建矩形
  PDF.创建矩形({
    x: 100,
    y: 100,
    宽度: 200,
    高度: 100,
    边框颜色: '#FF0000',
    填充颜色: '#FFFF00',
    线宽: 2
  }),
  
  // 创建圆形
  PDF.创建圆形({
    x: 200,
    y: 300,
    半径X: 50,
    半径Y: 50,
    边框颜色: '#0000FF',
    填充颜色: '#00FFFF'
  }),
  
  // 创建线条
  PDF.创建线条({
    x1: 50,
    y1: 400,
    x2: 450,
    y2: 400,
    颜色: '#00FF00',
    线宽: 3,
    虚线: [10, 5]
  }),
  
  // 创建多边形
  PDF.创建多边形([
    { x: 200, y: 450 },
    { x: 250, y: 520 },
    { x: 150, y: 520 }
  ], {
    边框颜色: '#FF00FF',
    填充颜色: '#FFAAAA',
    线宽: 1
  }),
  
  // 添加复杂文本样式
  PDF.创建段落([
    { text: '这是加粗文本', bold: true },
    { text: ' 这是斜体文本', italics: true },
    { text: ' 这是下划线文本', decoration: 'underline' },
    { text: ' 这是红色文本', color: 'red' },
    { text: ' 这是大号文本', fontSize: 16 }
  ]),
  
  // 创建绝对定位元素
  PDF.创建绝对定位元素(
    PDF.创建文本元素('绝对定位文本', { fontSize: 14, color: 'blue' }),
    50,
    150
  ),
  
  // 创建二维码
  PDF.创建二维码('https://example.com', { size: 80 }),
  
  // 创建条形码
  PDF.创建条形码('123456789012', {
    类型: PDF.条形码类型.EAN13,
    宽度: 2,
    高度: 60
  })
], {
  页面尺寸: PDF.页面尺寸.A4,
  样式: PDF.创建样式系统({
    highlight: { color: 'yellow', backgroundColor: 'black' },
    code: { fontFamily: 'Courier', fontSize: 10, color: 'green' }
  })
});

// 生成图形文档
async function 生成图形文档() {
  try {
    await PDF.生成并保存PDF(图形文档定义, './图形文档.pdf');
    console.log('图形文档生成成功！');
  } catch (错误) {
    console.error('图形文档生成失败:', 错误);
  }
}

生成图形文档();
```

#### Redis操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/Redis/index.js
- 功能: 提供Redis客户端的中文API封装，支持连接管理、键值操作、哈希操作、列表操作、集合操作、有序集合操作、发布订阅等功能

**核心特性**
- 完整支持Redis客户端的连接和管理
- 提供丰富的键值操作API，包括基本操作和高级操作
- 支持Redis的所有数据类型操作（字符串、哈希、列表、集合、有序集合）
- 提供发布订阅功能和事务操作
- 包含服务器管理和监控功能
- 保持与原始Redis API的功能兼容性，同时提供中文接口

**命令总数：50个**

**客户端管理** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建客户端 | 配置 | Object | 创建Redis客户端实例 | RedisClient |
| 连接 | 客户端, 回调函数 | RedisClient, Function | 连接到Redis服务器 | void |
| 断开连接 | 客户端 | RedisClient | 断开与Redis服务器的连接 | Promise |
| 检查连接状态 | 客户端 | RedisClient | 检查Redis连接状态 | boolean |
| 获取客户端ID | 客户端 | RedisClient | 生成Redis客户端实例ID | Promise<string> |

**基础键值操作** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置 | 客户端, 键, 值, 选项 | RedisClient, string, any, Object | 设置键值对 | Promise<string> |
| 获取 | 客户端, 键 | RedisClient, string | 获取键对应的值 | Promise<string> |
| 删除 | 客户端, 键 | RedisClient, string\|Array | 删除键 | Promise<number> |
| 是否存在 | 客户端, 键 | RedisClient, string | 检查键是否存在 | Promise<boolean> |
| 设置过期时间 | 客户端, 键, 秒数 | RedisClient, string, number | 设置键的过期时间 | Promise<number> |
| 获取剩余过期时间 | 客户端, 键 | RedisClient, string | 获取键的剩余过期时间 | Promise<number> |
| 移除过期时间 | 客户端, 键 | RedisClient, string | 移除键的过期时间 | Promise<number> |

**数值操作** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 递增 | 客户端, 键 | RedisClient, string | 递增数字 | Promise<number> |
| 递减 | 客户端, 键 | RedisClient, string | 递减数字 | Promise<number> |
| 增加 | 客户端, 键, 增量 | RedisClient, string, number | 增加指定值 | Promise<number> |
| 减少 | 客户端, 键, 减量 | RedisClient, string, number | 减少指定值 | Promise<number> |

**哈希操作** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置哈希字段 | 客户端, 键, 字段, 值 | RedisClient, string, string, any | 设置哈希字段值 | Promise<number> |
| 设置哈希多个字段 | 客户端, 键, 数据 | RedisClient, string, Object | 批量设置哈希字段值 | Promise<number> |
| 获取哈希字段 | 客户端, 键, 字段 | RedisClient, string, string | 获取哈希字段值 | Promise<string> |
| 获取哈希所有字段 | 客户端, 键 | RedisClient, string | 获取所有哈希字段和值 | Promise<Object> |
| 删除哈希字段 | 客户端, 键, 字段 | RedisClient, string, string\|Array | 删除哈希字段 | Promise<number> |
| 哈希字段是否存在 | 客户端, 键, 字段 | RedisClient, string, string | 检查哈希字段是否存在 | Promise<boolean> |

**列表操作** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 列表头部添加 | 客户端, 键, 元素 | RedisClient, string, any | 添加元素到列表头部 | Promise<number> |
| 列表尾部添加 | 客户端, 键, 元素 | RedisClient, string, any | 添加元素到列表尾部 | Promise<number> |
| 获取列表长度 | 客户端, 键 | RedisClient, string | 获取列表长度 | Promise<number> |
| 获取列表元素 | 客户端, 键, 开始索引, 结束索引 | RedisClient, string, number, number | 获取列表元素范围 | Promise<Array> |
| 列表头部移除 | 客户端, 键 | RedisClient, string | 从列表头部移除元素 | Promise<string> |
| 列表尾部移除 | 客户端, 键 | RedisClient, string | 从列表尾部移除元素 | Promise<string> |

**集合操作** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 集合添加成员 | 客户端, 键, 成员 | RedisClient, string, any | 添加成员到集合 | Promise<number> |
| 集合移除成员 | 客户端, 键, 成员 | RedisClient, string, any | 从集合移除成员 | Promise<number> |
| 集合成员是否存在 | 客户端, 键, 成员 | RedisClient, string, any | 检查集合成员是否存在 | Promise<boolean> |
| 获取集合所有成员 | 客户端, 键 | RedisClient, string | 获取集合所有成员 | Promise<Array> |
| 获取集合大小 | 客户端, 键 | RedisClient, string | 获取集合大小 | Promise<number> |

**有序集合操作** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 有序集合添加成员 | 客户端, 键, 分数, 成员 | RedisClient, string, number, any | 添加成员和分数到有序集合 | Promise<number> |
| 有序集合批量添加 | 客户端, 键, 成员列表 | RedisClient, string, Array | 批量添加成员和分数到有序集合 | Promise<number> |
| 获取有序集合成员分数 | 客户端, 键, 成员 | RedisClient, string, any | 获取有序集合成员分数 | Promise<string> |
| 获取有序集合范围成员 | 客户端, 键, 开始索引, 结束索引 | RedisClient, string, number, number | 获取有序集合范围成员 | Promise<Array> |

**发布订阅功能** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 发布消息 | 客户端, 频道, 消息 | RedisClient, string, string | 发布消息到频道 | Promise<number> |
| 订阅频道 | 客户端, 频道, 回调函数 | RedisClient, string, Function | 订阅频道并处理消息 | RedisClient |

**服务器操作** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 执行命令 | 客户端, 命令, ...参数 | RedisClient, string, any... | 执行原始Redis命令 | Promise<any> |
| 获取服务器信息 | 客户端, 部分 | RedisClient, string | 获取Redis服务器信息 | Promise<Object> |
| 清空数据库 | 客户端 | RedisClient | 清空当前数据库 | Promise<string> |
| 清空所有数据库 | 客户端 | RedisClient | 清空所有数据库 | Promise<string> |
| 监控 | 客户端, 回调函数 | RedisClient, Function | 监控Redis命令执行 | void |
| 获取所有键 | 客户端, 模式 | RedisClient, string | 获取匹配模式的所有键 | Promise<Array> |

**工具函数** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始Redis | 无 | 无 | 获取原始Redis模块 | Object |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个Redis模块
const Redis = require('./zh/后端/Redis/index.js');
```

**基本连接和键值操作示例:**
```javascript
const Redis = require('./zh/后端/Redis/index.js');

// 创建Redis客户端
const 客户端 = Redis.创建客户端({
  url: 'redis://localhost:6379',
  password: 'your_password',
  database: 0
});

// 连接到Redis服务器
Redis.连接(客户端, (错误) => {
  if (错误) {
    console.error('连接失败:', 错误);
    return;
  }
  console.log('Redis连接成功！');
  
  // 执行基本操作
  执行基本操作();
});

// 基本键值操作
async function 执行基本操作() {
  try {
    // 设置键值对
    await Redis.设置(客户端, '用户:1:姓名', '张三');
    await Redis.设置(客户端, '用户:1:年龄', '30');
    await Redis.设置(客户端, '用户:1:城市', '北京');
    
    // 设置过期时间（1小时后过期）
    await Redis.设置过期时间(客户端, '用户:1:临时令牌', 'abc123', 3600);
    
    // 获取值
    const 姓名 = await Redis.获取(客户端, '用户:1:姓名');
    const 年龄 = await Redis.获取(客户端, '用户:1:年龄');
    
    console.log('获取到的值:', 姓名, 年龄);
    
    // 检查键是否存在
    const 是否存在 = await Redis.是否存在(客户端, '用户:1:电话');
    console.log('电话键是否存在:', 是否存在);
    
    // 获取剩余过期时间
    const 剩余时间 = await Redis.获取剩余过期时间(客户端, '用户:1:临时令牌');
    console.log('临时令牌剩余时间（秒）:', 剩余时间);
    
    // 递增操作
    await Redis.设置(客户端, '访问计数器', '0');
    await Redis.递增(客户端, '访问计数器');
    await Redis.递增(客户端, '访问计数器');
    const 计数 = await Redis.获取(客户端, '访问计数器');
    console.log('访问计数:', 计数);
    
    // 清理操作
    await Redis.删除(客户端, ['用户:1:姓名', '用户:1:年龄', '用户:1:城市', '访问计数器']);
    
  } catch (错误) {
    console.error('操作失败:', 错误);
  } finally {
    // 断开连接
    await Redis.断开连接(客户端);
    console.log('Redis连接已断开');
  }
}
```

**哈希操作示例:**
```javascript
const Redis = require('./zh/后端/Redis/index.js');

async function 哈希操作示例() {
  const 客户端 = Redis.创建客户端();
  
  try {
    // 连接客户端
    await new Promise((resolve, reject) => {
      Redis.连接(客户端, (错误) => {
        if (错误) reject(错误);
        else resolve();
      });
    });
    
    // 使用哈希存储用户信息
    await Redis.设置哈希多个字段(客户端, '用户:1', {
      姓名: '李四',
      年龄: '28',
      邮箱: 'lisi@example.com',
      地址: '上海市浦东新区',
      注册时间: new Date().toISOString()
    });
    
    // 获取单个字段
    const 邮箱 = await Redis.获取哈希字段(客户端, '用户:1', '邮箱');
    console.log('用户邮箱:', 邮箱);
    
    // 获取所有字段
    const 用户信息 = await Redis.获取哈希所有字段(客户端, '用户:1');
    console.log('用户完整信息:', 用户信息);
    
    // 更新单个字段
    await Redis.设置哈希字段(客户端, '用户:1', '年龄', '29');
    
    // 检查字段是否存在
    const 是否存在 = await Redis.哈希字段是否存在(客户端, '用户:1', '电话');
    console.log('电话字段是否存在:', 是否存在);
    
    // 删除字段
    await Redis.删除哈希字段(客户端, '用户:1', '地址');
    
    // 再次获取完整信息
    const 更新后信息 = await Redis.获取哈希所有字段(客户端, '用户:1');
    console.log('更新后的用户信息:', 更新后信息);
    
  } catch (错误) {
    console.error('哈希操作失败:', 错误);
  } finally {
    // 清理和断开连接
    await Redis.删除(客户端, '用户:1');
    await Redis.断开连接(客户端);
  }
}

哈希操作示例();
```

**列表和集合操作示例:**
```javascript
const Redis = require('./zh/后端/Redis/index.js');

async function 数据结构操作示例() {
  const 客户端 = Redis.创建客户端();
  
  try {
    // 连接客户端
    await new Promise((resolve) => Redis.连接(客户端, resolve));
    
    // ========== 列表操作 ==========
    console.log('===== 列表操作 =====');
    
    // 添加元素到列表头部和尾部
    await Redis.列表头部添加(客户端, '消息队列', '消息3');
    await Redis.列表头部添加(客户端, '消息队列', '消息2');
    await Redis.列表头部添加(客户端, '消息队列', '消息1');
    await Redis.列表尾部添加(客户端, '消息队列', '消息4');
    
    // 获取列表长度
    const 队列长度 = await Redis.获取列表长度(客户端, '消息队列');
    console.log('消息队列长度:', 队列长度);
    
    // 获取所有消息
    const 所有消息 = await Redis.获取列表元素(客户端, '消息队列', 0, -1);
    console.log('所有消息:', 所有消息);
    
    // 消费消息（从头部移除）
    const 消费消息 = await Redis.列表头部移除(客户端, '消息队列');
    console.log('消费的消息:', 消费消息);
    
    // ========== 集合操作 ==========
    console.log('\n===== 集合操作 =====');
    
    // 添加集合成员
    await Redis.集合添加成员(客户端, '用户组:管理员', ['用户1', '用户2', '用户3']);
    await Redis.集合添加成员(客户端, '用户组:普通用户', ['用户3', '用户4', '用户5']);
    
    // 获取集合大小
    const 管理员数量 = await Redis.获取集合大小(客户端, '用户组:管理员');
    console.log('管理员数量:', 管理员数量);
    
    // 检查成员是否存在
    const 是否管理员 = await Redis.集合成员是否存在(客户端, '用户组:管理员', '用户4');
    console.log('用户4是否为管理员:', 是否管理员);
    
    // 获取所有成员
    const 所有管理员 = await Redis.获取集合所有成员(客户端, '用户组:管理员');
    console.log('所有管理员:', 所有管理员);
    
    // ========== 有序集合操作 ==========
    console.log('\n===== 有序集合操作 =====');
    
    // 添加有序集合成员（排行榜示例）
    await Redis.有序集合添加成员(客户端, '用户积分排行榜', 1000, '用户1');
    await Redis.有序集合添加成员(客户端, '用户积分排行榜', 1500, '用户2');
    await Redis.有序集合添加成员(客户端, '用户积分排行榜', 800, '用户3');
    await Redis.有序集合添加成员(客户端, '用户积分排行榜', 2000, '用户4');
    
    // 获取成员分数
    const 用户2积分 = await Redis.获取有序集合成员分数(客户端, '用户积分排行榜', '用户2');
    console.log('用户2的积分:', 用户2积分);
    
    // 获取前三名（分数从高到低）
    const 前三名 = await Redis.获取有序集合范围成员(客户端, '用户积分排行榜', 0, 2);
    console.log('积分排行榜前三名:', 前三名);
    
  } catch (错误) {
    console.error('数据结构操作失败:', 错误);
  } finally {
    // 清理和断开连接
    await Redis.删除(客户端, ['消息队列', '用户组:管理员', '用户组:普通用户', '用户积分排行榜']);
    await Redis.断开连接(客户端);
  }
}

数据结构操作示例();
```

**发布订阅示例:**
```javascript
const Redis = require('./zh/后端/Redis/index.js');

async function 发布订阅示例() {
  // 创建发布客户端和订阅客户端
  const 发布客户端 = Redis.创建客户端();
  const 订阅客户端 = Redis.创建客户端();
  
  try {
    // 连接两个客户端
    await Promise.all([
      new Promise(resolve => Redis.连接(发布客户端, resolve)),
      new Promise(resolve => Redis.连接(订阅客户端, resolve))
    ]);
    
    console.log('开始发布订阅演示...');
    
    // 订阅频道
    const 频道 = '通知频道';
    Redis.订阅频道(订阅客户端, 频道, (消息) => {
      console.log(`收到消息: ${消息}`);
    });
    
    // 发布几条消息
    await new Promise(resolve => setTimeout(resolve, 100)); // 等待订阅建立
    
    await Redis.发布消息(发布客户端, 频道, '这是第一条通知消息');
    await Redis.发布消息(发布客户端, 频道, '这是第二条通知消息');
    await Redis.发布消息(发布客户端, 频道, JSON.stringify({ 类型: '系统通知', 内容: '系统将在5分钟后维护', 时间: new Date().toISOString() }));
    
    // 等待消息处理完成
    await new Promise(resolve => setTimeout(resolve, 500));
    
  } catch (错误) {
    console.error('发布订阅操作失败:', 错误);
  } finally {
    // 断开连接
    await Promise.all([
      Redis.断开连接(发布客户端),
      Redis.断开连接(订阅客户端)
    ]);
    console.log('发布订阅演示结束');
  }
}

发布订阅示例();
```

**Express服务器集成示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const Redis = require('./zh/后端/Redis/index.js');

// 创建Express应用
const 应用 = Express.创建应用();

// 创建Redis客户端并连接
const Redis客户端 = Redis.创建客户端();
Redis.连接(Redis客户端, (错误) => {
  if (错误) {
    console.error('Redis连接失败:', 错误);
  } else {
    console.log('Redis连接成功');
  }
});

// 配置中间件
Express.使用中间件(应用, Express.解析JSON(应用));

// 计数器API（演示基本操作）
Express.监听GET请求(应用, '/api/counter', async (请求, 响应) => {
  try {
    // 递增计数器
    await Redis.递增(Redis客户端, 'api_访问计数器');
    
    // 获取当前计数
    const 计数 = await Redis.获取(Redis客户端, 'api_访问计数器');
    
    Express.发送JSON(响应, {
      计数: 计数,
      时间: new Date().toLocaleString('zh-CN')
    });
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: 'Redis操作失败' });
  }
});

// 用户信息API（演示哈希操作）
Express.监听POST请求(应用, '/api/users/:id', async (请求, 响应) => {
  try {
    const 用户ID = Express.获取URL参数(请求, 'id');
    const 用户数据 = Express.获取请求体(请求);
    
    // 验证输入
    if (!用户数据.姓名) {
      Express.设置状态码(响应, 400);
      return Express.发送JSON(响应, { 错误: '姓名不能为空' });
    }
    
    // 存储用户信息
    await Redis.设置哈希多个字段(Redis客户端, `用户:${用户ID}`, 用户数据);
    
    // 设置过期时间（7天后过期）
    await Redis.设置过期时间(Redis客户端, `用户:${用户ID}`, 7 * 24 * 60 * 60);
    
    Express.设置状态码(响应, 201);
    Express.发送JSON(响应, {
      成功: true,
      消息: '用户信息已保存',
      用户ID: 用户ID
    });
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: '保存失败' });
  }
});

// 获取用户信息
Express.监听GET请求(应用, '/api/users/:id', async (请求, 响应) => {
  try {
    const 用户ID = Express.获取URL参数(请求, 'id');
    const 用户信息 = await Redis.获取哈希所有字段(Redis客户端, `用户:${用户ID}`);
    
    if (!用户信息 || Object.keys(用户信息).length === 0) {
      Express.设置状态码(响应, 404);
      return Express.发送JSON(响应, { 错误: '用户不存在' });
    }
    
    Express.发送JSON(响应, { 用户信息 });
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: '查询失败' });
  }
});

// 启动服务器
Express.启动服务器(应用, 3000, () => {
  console.log('服务器运行在 http://localhost:3000');
  console.log('API端点:');
  console.log('  GET  /api/counter - 获取访问计数');
  console.log('  POST /api/users/:id - 保存用户信息');
  console.log('  GET  /api/users/:id - 获取用户信息');
});

// 优雅关闭
process.on('SIGINT', async () => {
  console.log('正在关闭服务器...');
  await Redis.断开连接(Redis客户端);
  process.exit(0);
});
```

**高级操作示例:**
```javascript
const Redis = require('./zh/后端/Redis/index.js');

async function 高级操作示例() {
  const 客户端 = Redis.创建客户端();
  
  try {
    // 连接客户端
    await new Promise(resolve => Redis.连接(客户端, resolve));
    console.log('Redis连接成功');
    
    // ========== 服务器信息获取 ==========
    console.log('\n===== 服务器信息 =====');
    const 服务器信息 = await Redis.获取服务器信息(客户端);
    console.log('Redis版本:', 服务器信息.redis_version);
    console.log('已连接客户端数:', 服务器信息.connected_clients);
    console.log('内存使用:', 服务器信息.used_memory_human);
    
    // ========== 键模式匹配 ==========
    console.log('\n===== 键模式匹配 =====');
    // 先创建一些测试键
    await Redis.设置(客户端, '用户:1:数据', '用户1数据');
    await Redis.设置(客户端, '用户:2:数据', '用户2数据');
    await Redis.设置(客户端, '产品:1:信息', '产品1信息');
    
    // 获取所有用户相关的键
    const 用户键 = await Redis.获取所有键(客户端, '用户:*');
    console.log('用户相关的键:', 用户键);
    
    // 获取所有以数据结尾的键
    const 数据键 = await Redis.获取所有键(客户端, '*:数据');
    console.log('以数据结尾的键:', 数据键);
    
    // ========== 原始命令执行 ==========
    console.log('\n===== 执行原始命令 =====');
    // 执行INFO命令获取内存信息
    const 内存信息 = await Redis.执行命令(客户端, 'INFO', 'memory');
    console.log('内存信息命令结果:', 内存信息.substring(0, 200) + '...');
    
    // ========== 事务模拟 ==========
    console.log('\n===== 事务模拟 =====');
    // 注意：这个示例模拟事务，实际Redis事务需要使用MULTI/EXEC
    try {
      // 开始事务操作
      await Redis.设置(客户端, '事务:测试键1', '值1');
      await Redis.设置(客户端, '事务:测试键2', '值2');
      await Redis.设置(客户端, '事务:测试键3', '值3');
      console.log('事务操作成功完成');
    } catch (事务错误) {
      console.error('事务操作失败，执行回滚:', 事务错误);
      // 回滚操作 - 删除已设置的键
      await Redis.删除(客户端, ['事务:测试键1', '事务:测试键2', '事务:测试键3']);
    }
    
    // ========== 监控示例 ==========
    console.log('\n===== 监控示例 =====');
    console.log('开始监控Redis命令执行（5秒后停止）');
    
    Redis.监控(客户端, (监控数据) => {
      console.log(`监控到命令: ${监控数据.命令} ${监控数据.参数.join(' ')}`);
    });
    
    // 执行一些命令用于监控
    await new Promise(resolve => setTimeout(resolve, 100));
    await Redis.设置(客户端, '测试:监控键', '监控值');
    await Redis.获取(客户端, '测试:监控键');
    
    // 等待监控演示完成
    await new Promise(resolve => setTimeout(resolve, 5000));
    
  } catch (错误) {
    console.error('高级操作失败:', 错误);
  } finally {
    // 清理测试数据
    console.log('\n清理测试数据...');
    const 测试键 = await Redis.获取所有键(客户端, '测试:*');
    const 用户键 = await Redis.获取所有键(客户端, '用户:*');
    const 产品键 = await Redis.获取所有键(客户端, '产品:*');
    const 事务键 = await Redis.获取所有键(客户端, '事务:*');
    
    const 所有要删除的键 = [...测试键, ...用户键, ...产品键, ...事务键];
    if (所有要删除的键.length > 0) {
      await Redis.删除(客户端, 所有要删除的键);
      console.log('已删除测试键数量:', 所有要删除的键.length);
    }
    
    // 断开连接
    await Redis.断开连接(客户端);
    console.log('Redis连接已断开');
  }
}

高级操作示例();
```
#### Word文档操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/Word/index.js
- 功能: 提供Word文档的中文API封装，支持文档创建、读取、修改、格式化、内容操作等功能，基于docx库实现

**核心特性**
- 完整支持Word文档的创建、读取、保存和转换功能
- 提供丰富的文档内容操作API，包括文本、段落、表格、图片等元素的处理
- 支持文档格式设置、样式应用、页眉页脚配置等高级功能
- 提供文档内容搜索、替换、提取等实用功能
- 支持文档保护、合并、差异比较等管理功能
- 保持与原始docx库API的功能兼容性，同时提供中文接口

**命令总数：52个**

**核心文档操作** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建文档 | 文档选项 | Object | 创建新的Word文档 | docx.Document |
| 保存文档到文件 | 文档, 文件路径 | Object, string | 保存文档到文件系统 | Promise<string> |
| 转换为Buffer | 文档 | Object | 将文档转换为Buffer | Promise<Buffer> |
| 读取Word文档 | 文件路径 | string | 从文件读取Word文档 | Promise<Object> |
| 创建复杂文档 | 文档配置 | Object | 创建带有复杂结构的文档 | docx.Document |

**文档结构元素** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建节 | 节选项 | Object | 创建文档节 | docx.Section |
| 创建段落 | 文本内容, 段落选项 | string\|Array, Object | 创建文本段落 | docx.Paragraph |
| 创建标题 | 标题文本, 级别, 标题选项 | string, number, Object | 创建标题段落 | docx.Paragraph |

**文本元素** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建文本 | 文本, 文本选项 | string, Object | 创建纯文本元素 | docx.TextRun |
| 创建超链接 | 链接文本, 链接URL, 链接选项 | string, string, Object | 创建超链接 | docx.ExternalHyperlink |
| 创建书签 | 书签名称, 内容, 书签选项 | string, string\|Object, Object | 创建文档书签 | docx.Bookmark |

**表格相关** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建表格 | 表格数据, 表格选项 | Array, Object | 创建表格 | docx.Table |
| 创建表格单元格 | 内容, 单元格选项 | string\|Array, Object | 创建表格单元格 | docx.TableCell |

**媒体和图形元素** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建图片 | 图片数据, 图片选项 | string\|Buffer, Object | 创建图片段落 | docx.Paragraph |
| 创建分隔线 | 分隔线选项 | Object | 创建分隔线段落 | docx.Paragraph |

**列表元素** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建项目符号列表 | 列表项, 列表选项 | Array, Object | 创建项目符号列表 | Array<docx.Paragraph> |
| 创建编号列表 | 列表项, 列表选项 | Array, Object | 创建编号列表 | Array<docx.Paragraph> |

**导航和目录** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建目录 | 目录选项 | Object | 创建目录 | Array<docx.Paragraph> |
| 创建页码 | 页码选项 | Object | 创建页码文本 | docx.PageNumber |

**页眉和页脚** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建页眉 | 页眉内容, 页眉选项 | Array\|Object, Object | 创建文档页眉 | docx.Header |
| 创建页脚 | 页脚内容, 页脚选项 | Array\|Object, Object | 创建文档页脚 | docx.Footer |

**样式系统** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建样式 | 样式名称, 样式属性 | string, Object | 创建样式定义 | docx.Style |
| 创建样式集合 | 样式数组 | Array | 创建样式集合 | docx.Styles |

**页面布局** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建页面尺寸 | 宽度, 高度, 单位 | number, number, string | 创建页面尺寸定义 | Object |
| 创建页面边距 | 顶部, 右侧, 底部, 左侧, 单位 | number, number, number, number, string | 创建页面边距定义 | Object |

**其他元素** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建文本框 | 文本框内容, 文本框选项 | Array\|Object, Object | 创建文本框 | docx.Textbox |

**文档读取与分析** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 从Buffer加载文档 | 缓冲区 | Buffer | 从Buffer加载Word文档 | Promise<Object> |
| 获取文档节 | 文档 | Object | 获取文档中的所有节 | Array |
| 获取文档文本 | 文档 | Object | 提取文档中的所有文本内容 | string |
| 搜索文本 | 文档, 搜索文本 | Object, string | 在文档中搜索文本 | Array |
| 替换文本 | 文档, 查找文本, 替换文本 | Object, string, string | 替换文档中的文本 | Object |

**文档内容操作** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 添加水印 | 文档, 水印文本, 水印选项 | Object, string, Object | 为文档添加水印 | Object |
| 设置文档属性 | 文档, 属性 | Object, Object | 设置文档属性 | Object |
| 获取文档属性 | 文档 | Object | 获取文档属性 | Object |
| 添加页脚页码 | 文档, 页码选项 | Object, Object | 为文档添加页脚页码 | Object |
| 提取表格数据 | 文档 | Object | 从文档中提取表格数据 | Array |

**文档管理** (6个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 合并文档 | 文档列表 | Array | 合并多个Word文档 | Object |
| 提取图片 | 文档, 输出目录 | Object, string | 从文档中提取图片 | Promise<Array> |
| 保护文档 | 文档, 密码, 保护选项 | Object, string, Object | 保护文档 | Object |
| 移除保护 | 文档 | Object | 移除文档保护 | Object |
| 压缩文档 | 文档 | Object | 压缩文档 | Object |
| 比较文档 | 文档1, 文档2 | Object, Object | 比较两个文档的差异 | Object |

**高级功能** (4个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建邮件合并 | 文档, 数据, 选项 | Object, Array, Object | 创建邮件合并功能 | Array |
| 导出为HTML | 文档 | Object | 导出文档为HTML格式 | string |
| 导出为Markdown | 文档 | Object | 导出文档为Markdown格式 | string |
| 应用模板 | 文档, 模板 | Object, Object | 应用模板到文档 | Object |

**常量与工具函数** (2个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 验证docx库 | 无 | 无 | 验证docx库是否可用 | boolean |
| 获取原始docx | 无 | 无 | 获取原始docx模块 | Object |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入整个Word模块
const Word = require('./zh/后端/Word/index.js');
```

**基本文档创建示例:**
```javascript
const Word = require('./zh/后端/Word/index.js');
const path = require('path');

async function 创建基本文档() {
  try {
    // 验证docx库
    Word.验证docx库();
    
    // 创建新文档
    const 文档 = Word.创建文档();
    
    // 创建节
    const 节 = Word.创建节({
      properties: {
        pageSize: Word.页面尺寸预设.A4,
        pageMargin: Word.创建页面边距(1440, 1440, 1440, 1440) // 1英寸边距
      },
      children: [
        // 添加标题
        Word.创建标题('Word文档操作示例', 1, { 
          alignment: Word.对齐方式.居中,
          spacing: { after: 200 }
        }),
        
        // 添加副标题
        Word.创建标题('基本文档创建演示', 2, { 
          alignment: Word.对齐方式.居中,
          spacing: { after: 150 }
        }),
        
        // 添加日期
        Word.创建段落(`创建日期: ${new Date().toLocaleDateString('zh-CN')}`, { 
          alignment: Word.对齐方式.居中,
          spacing: { after: 300 }
        }),
        
        // 添加正文段落
        Word.创建段落('这是一个使用中文API封装创建的Word文档示例。这个示例展示了如何使用Word模块创建基本的文档结构，包括标题、段落和格式化文本。', { 
          spacing: { after: 150 }
        }),
        
        Word.创建段落('中文API封装使得文档操作更加直观和易于理解，特别适合中文开发者使用。下面是一些格式化文本的示例：', { 
          spacing: { after: 150 }
        }),
        
        // 添加格式化文本
        Word.创建段落([
          Word.创建文本('这是粗体文本', { bold: true }),
          Word.创建文本('，这是普通文本，'),
          Word.创建文本('这是斜体文本', { italics: true }),
          Word.创建文本('，这是带下划线的文本', { underline: true }),
          Word.创建文本('，这是红色文本', { color: 'FF0000' })
        ], { spacing: { after: 150 } }),
        
        // 添加超链接
        Word.创建段落([
          Word.创建文本('访问项目首页：'),
          Word.创建超链接('GitHub仓库', 'https://github.com')
        ], { spacing: { after: 150 } })
      ]
    });
    
    // 将节添加到文档
    文档.addSection(节);
    
    // 保存文档
    const 保存路径 = path.join(__dirname, '基本文档示例.docx');
    await Word.保存文档到文件(文档, 保存路径);
    
    console.log(`文档已成功保存到: ${保存路径}`);
    
  } catch (错误) {
    console.error('创建文档时出错:', 错误);
  }
}

// 执行函数
创建基本文档();
```

**表格和列表操作示例:**
```javascript
const Word = require('./zh/后端/Word/index.js');
const path = require('path');

async function 表格和列表示例() {
  try {
    // 创建新文档
    const 文档 = Word.创建文档();
    
    // 创建节
    const 节 = Word.创建节();
    
    // 添加标题
    节.addItem(Word.创建标题('表格和列表操作示例', 1, { 
      alignment: Word.对齐方式.居中,
      spacing: { after: 200 }
    }));
    
    // 添加表格标题
    节.addItem(Word.创建标题('用户信息表格', 2, { 
      spacing: { after: 100 }
    }));
    
    // 创建表格数据
    const 表格数据 = [
      ['ID', '姓名', '年龄', '城市', '职业'],
      ['1', '张三', '30', '北京', '工程师'],
      ['2', '李四', '28', '上海', '设计师'],
      ['3', '王五', '35', '广州', '产品经理'],
      ['4', '赵六', '42', '深圳', '销售总监']
    ];
    
    // 创建表格
    const 表格 = Word.创建表格(表格数据, {
      style: 'Table Grid',
      width: {
        size: 100,
        type: 'percent'
      },
      // 设置表头样式
      行样式: [{
        children: 表格数据[0].map(() => ({
          shading: {
            fill: 'DDDDDD'
          },
          borders: {
            top: { style: 'single', size: 1, color: '000000' },
            bottom: { style: 'single', size: 1, color: '000000' },
            left: { style: 'single', size: 1, color: '000000' },
            right: { style: 'single', size: 1, color: '000000' }
          }
        }))
      }]
    });
    
    节.addItem(表格);
    
    // 添加段落分隔
    节.addItem(Word.创建段落('', { spacing: { after: 200 } }));
    
    // 添加项目符号列表标题
    节.addItem(Word.创建标题('项目符号列表', 2, { 
      spacing: { after: 100 }
    }));
    
    // 创建项目符号列表
    const 项目符号列表 = Word.创建项目符号列表([
      '项目符号列表项1',
      '项目符号列表项2',
      '项目符号列表项3',
      '项目符号列表项4',
      '项目符号列表项5'
    ], { 
      level: 0,
      spacing: { after: 50 }
    });
    
    项目符号列表.forEach(项 => 节.addItem(项));
    
    // 添加段落分隔
    节.addItem(Word.创建段落('', { spacing: { after: 200 } }));
    
    // 添加编号列表标题
    节.addItem(Word.创建标题('编号列表', 2, { 
      spacing: { after: 100 }
    }));
    
    // 创建编号列表
    const 编号列表 = Word.创建编号列表([
      '第一步：准备工作',
      '第二步：开始实施',
      '第三步：测试验证',
      '第四步：部署上线',
      '第五步：运维监控'
    ], { 
      level: 0,
      spacing: { after: 50 }
    });
    
    编号列表.forEach(项 => 节.addItem(项));
    
    // 将节添加到文档
    文档.addSection(节);
    
    // 保存文档
    const 保存路径 = path.join(__dirname, '表格和列表示例.docx');
    await Word.保存文档到文件(文档, 保存路径);
    
    console.log(`文档已成功保存到: ${保存路径}`);
    
  } catch (错误) {
    console.error('创建表格和列表时出错:', 错误);
  }
}

// 执行函数
表格和列表示例();
```

**复杂文档创建示例:**
```javascript
const Word = require('./zh/后端/Word/index.js');
const path = require('path');

async function 创建复杂文档示例() {
  try {
    // 使用创建复杂文档函数
    const 文档 = Word.创建复杂文档({
      包含目录: true,
      目录选项: {
        超链接: true,
        起始级别: 1,
        结束级别: 3
      },
      标题: '产品需求文档',
      标题样式: {
        font: '微软雅黑',
        size: 36,
        color: '000000',
        spacing: { after: 200 }
      },
      副标题: '新一代智能办公系统',
      副标题样式: {
        font: '微软雅黑',
        size: 24,
        color: '333333'
      },
      作者: '产品部',
      日期: new Date().toLocaleDateString('zh-CN'),
      摘要: '本文档详细描述了新一代智能办公系统的产品需求，包括系统概述、功能模块、技术架构、界面设计等内容。该系统旨在提升企业办公效率，简化工作流程，提供智能化的办公体验。',
      摘要样式: {
        font: '宋体',
        size: 20,
        spacing: {
          line: 360,
          after: 200
        }
      },
      段落: [
        '本产品需求文档（PRD）旨在定义新一代智能办公系统的功能和非功能需求。该系统将集成多种办公功能，提供统一的用户界面和体验。',
        '系统的核心目标是提升企业内部协作效率，减少信息孤岛，实现数据的集中管理和智能分析。通过自动化工作流程和智能推荐，帮助用户更快地完成日常办公任务。',
        '本文档适用于产品经理、开发团队、测试团队以及所有参与产品设计和实现的相关人员。'
      ],
      段落样式: {
        font: '宋体',
        size: 20,
        spacing: {
          line: 360,
          after: 150
        }
      },
      列表标题: '系统核心功能',
      列表项: [
        '智能文档管理：支持文档的上传、下载、版本控制和权限管理',
        '协同办公：提供多人在线编辑、评论和任务分配功能',
        '智能会议：集成视频会议、日程安排和会议记录功能',
        '审批流程：可配置的工作流引擎，支持多级审批和条件分支',
        '数据分析：内置报表和数据可视化工具，提供智能决策支持'
      ],
      列表类型: 'numbered',
      列表样式: {
        spacing: { after: 100 }
      },
      表格标题: '系统模块规划',
      表格数据: [
        ['模块名称', '优先级', '开发周期', '负责人'],
        ['用户认证', '高', '2周', '张三'],
        ['文档管理', '高', '4周', '李四'],
        ['协同办公', '中', '3周', '王五'],
        ['审批流程', '中', '3周', '赵六'],
        ['数据分析', '低', '4周', '钱七']
      ],
      表格样式: {
        width: {
          size: 100,
          type: 'percent'
        },
        style: 'Table Grid'
      },
      页面方向: Word.页面方向.纵向,
      页面尺寸: Word.页面尺寸预设.A4,
      页面边距: Word.创建页面边距(1440, 1440, 1440, 1440)
    });
    
    // 保存文档
    const 保存路径 = path.join(__dirname, '复杂文档示例.docx');
    await Word.保存文档到文件(文档, 保存路径);
    
    console.log(`复杂文档已成功保存到: ${保存路径}`);
    
  } catch (错误) {
    console.error('创建复杂文档时出错:', 错误);
  }
}

// 执行函数
创建复杂文档示例();
```

**文档读取和修改示例:**
```javascript
const Word = require('./zh/后端/Word/index.js');
const path = require('path');

async function 读取和修改文档() {
  try {
    // 定义文档路径
    const 源文档路径 = path.join(__dirname, '需要修改的文档.docx'); // 请确保此文件存在
    const 目标文档路径 = path.join(__dirname, '修改后的文档.docx');
    
    // 读取现有文档
    console.log('正在读取文档...');
    const 文档 = await Word.读取Word文档(源文档路径);
    
    // 获取文档文本
    const 文档文本 = Word.获取文档文本(文档);
    console.log(`文档文本内容长度: ${文档文本.length} 字符`);
    
    // 搜索文本
    const 搜索结果 = Word.搜索文本(文档, '示例');
    console.log(`找到 ${搜索结果.length} 个"示例"文本匹配`);
    
    // 替换文本
    console.log('正在替换文本...');
    Word.替换文本(文档, '示例', '演示');
    
    // 获取文档属性
    const 文档属性 = Word.获取文档属性(文档);
    console.log('当前文档属性:', 文档属性);
    
    // 更新文档属性
    console.log('正在更新文档属性...');
    Word.设置文档属性(文档, {
      标题: '已修改的Word文档',
      主题: '文档处理示例',
      关键词: ['Word', '文档', '修改', '示例'],
      描述: '这是一个经过修改的Word文档示例',
      最后修改者: '文档处理脚本',
      修改日期: new Date().toISOString()
    });
    
    // 添加水印
    console.log('正在添加水印...');
    Word.添加水印(文档, '已修改', {
      颜色: 'FF0000',
      字号: 100,
      文本样式: {
        bold: true,
        italics: true
      }
    });
    
    // 添加页脚页码
    console.log('正在添加页脚页码...');
    Word.添加页脚页码(文档, {
      对齐方式: Word.对齐方式.居中,
      段落样式: {
        spacing: { before: 50, after: 50 }
      }
    });
    
    // 保存修改后的文档
    console.log('正在保存修改后的文档...');
    await Word.保存文档到文件(文档, 目标文档路径);
    
    // 提取表格数据（如果有）
    const 表格数据 = Word.提取表格数据(文档);
    console.log(`文档中包含 ${表格数据.length} 个表格`);
    
    if (表格数据.length > 0) {
      console.log('第一个表格的数据:');
      表格数据[0].forEach(行 => {
        console.log(行.join('\t'));
      });
    }
    
    console.log(`修改后的文档已保存到: ${目标文档路径}`);
    
  } catch (错误) {
    console.error('读取和修改文档时出错:', 错误);
  }
}

// 执行函数
读取和修改文档();
```

**Express服务器集成示例:**
```javascript
const Express = require('./zh/后端/Express/index.js');
const Word = require('./zh/后端/Word/index.js');
const fs = require('fs');
const path = require('path');

// 创建Express应用
const 应用 = Express.创建应用();

// 设置静态文件目录
Express.使用中间件(应用, Express.提供静态文件(应用, 'public'));

// 配置解析请求体
Express.使用中间件(应用, Express.解析JSON(应用));
Express.使用中间件(应用, Express.解析URL编码(应用));

// 配置文件上传中间件
const 文件上传 = require('express-fileupload');
Express.使用中间件(应用, 文件上传());

// 确保uploads目录存在
const uploadsDir = path.join(__dirname, 'uploads');
if (!fs.existsSync(uploadsDir)) {
  fs.mkdirSync(uploadsDir, { recursive: true });
}

// 确保downloads目录存在
const downloadsDir = path.join(__dirname, 'downloads');
if (!fs.existsSync(downloadsDir)) {
  fs.mkdirSync(downloadsDir, { recursive: true });
}

// 创建简单文档的API
Express.监听POST请求(应用, '/api/create-doc', async (请求, 响应) => {
  try {
    const { 标题, 内容 } = Express.获取请求体(请求);
    
    // 验证输入
    if (!标题 || !内容) {
      Express.设置状态码(响应, 400);
      return Express.发送JSON(响应, { 错误: '标题和内容不能为空' });
    }
    
    // 创建文档
    const 文档 = Word.创建文档();
    const 节 = Word.创建节();
    
    // 添加内容
    节.addItem(Word.创建标题(标题, 1));
    节.addItem(Word.创建段落('', { spacing: { after: 150 } }));
    
    // 将内容按行分割并添加
    const 段落 = 内容.split('\n');
    段落.forEach(段 => {
      if (段.trim()) {
        节.addItem(Word.创建段落(段, { 
          spacing: { after: 100 }
        }));
      }
    });
    
    文档.addSection(节);
    
    // 保存文档
    const 文件名 = `${Date.now()}-document.docx`;
    const 文件路径 = path.join(downloadsDir, 文件名);
    await Word.保存文档到文件(文档, 文件路径);
    
    // 返回文件路径
    Express.发送JSON(响应, {
      成功: true,
      文件名,
      文件URL: `/download/${文件名}`
    });
    
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: 错误.message });
  }
});

// 上传并处理Word文档的API
Express.监听POST请求(应用, '/api/process-doc', async (请求, 响应) => {
  try {
    // 检查文件是否上传
    if (!请求.files || !请求.files.文档) {
      Express.设置状态码(响应, 400);
      return Express.发送JSON(响应, { 错误: '没有上传文件' });
    }
    
    const 上传的文件 = 请求.files.文档;
    const { 查找文本, 替换文本: 替换为文本 } = Express.获取请求体(请求);
    
    // 保存上传的文件
    const 上传文件路径 = path.join(uploadsDir, 上传的文件.name);
    await 上传的文件.mv(上传文件路径);
    
    // 读取并处理文档
    const 文档 = await Word.读取Word文档(上传文件路径);
    
    // 替换文本
    if (查找文本 && 替换为文本) {
      Word.替换文本(文档, 查找文本, 替换为文本);
    }
    
    // 添加水印
    Word.添加水印(文档, '已处理', {
      颜色: 'FF0000',
      字号: 80
    });
    
    // 保存处理后的文档
    const 文件名 = `processed-${Date.now()}-${上传的文件.name}`;
    const 保存路径 = path.join(downloadsDir, 文件名);
    await Word.保存文档到文件(文档, 保存路径);
    
    // 删除上传的临时文件
    fs.unlinkSync(上传文件路径);
    
    Express.发送JSON(响应, {
      成功: true,
      文件名,
      文件URL: `/download/${文件名}`
    });
    
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: 错误.message });
  }
});

// 下载文件的API
Express.监听GET请求(应用, '/download/:filename', (请求, 响应) => {
  try {
    const 文件名 = Express.获取URL参数(请求, 'filename');
    const 文件路径 = path.join(downloadsDir, 文件名);
    
    // 检查文件是否存在
    if (!fs.existsSync(文件路径)) {
      Express.设置状态码(响应, 404);
      return Express.发送JSON(响应, { 错误: '文件不存在' });
    }
    
    // 发送文件
    Express.发送文件(响应, 文件路径, { 
      文件名,
      缓存控制: 'no-cache'
    });
    
  } catch (错误) {
    Express.设置状态码(响应, 500);
    Express.发送JSON(响应, { 错误: 错误.message });
  }
});

// 健康检查API
Express.监听GET请求(应用, '/health', (请求, 响应) => {
  Express.发送JSON(响应, { 
    状态: '正常',
    时间: new Date().toISOString(),
    服务: 'Word文档处理服务'
  });
});

// 启动服务器
const 端口 = 3000;
Express.启动服务器(应用, 端口, () => {
  console.log(`服务器运行在 http://localhost:${端口}`);
  console.log('可用API端点:');
  console.log('  POST /api/create-doc - 创建简单Word文档');
  console.log('  POST /api/process-doc - 上传并处理Word文档');
  console.log('  GET  /download/:filename - 下载生成的文档');
  console.log('  GET  /health - 健康检查');
});
```

**高级文档功能示例:**
```javascript
const Word = require('./zh/后端/Word/index.js');
const fs = require('fs');
const path = require('path');

async function 高级文档功能() {
  try {
    console.log('===== 高级Word文档功能演示 =====');
    
    // ========== 1. 文档比较 ==========
    console.log('\n1. 文档比较功能');
    
    // 创建两个用于比较的文档
    const 文档1 = Word.创建文档();
    const 文档2 = Word.创建文档();
    
    const 节1 = Word.创建节();
    节1.addItem(Word.创建段落('这是原始文档内容。'));
    节1.addItem(Word.创建段落('文档包含一些示例文本。'));
    文档1.addSection(节1);
    
    const 节2 = Word.创建节();
    节2.addItem(Word.创建段落('这是修改后的文档内容。'));
    节2.addItem(Word.创建段落('文档包含一些更新的示例文本。'));
    文档2.addSection(节2);
    
    // 比较文档
    const 差异 = Word.比较文档(文档1, 文档2);
    console.log('文档差异:', 差异);
    
    // ========== 2. 文档导出功能 ==========
    console.log('\n2. 文档导出功能');
    
    // 创建示例文档
    const 导出文档 = Word.创建文档();
    const 导出节 = Word.创建节();
    导出节.addItem(Word.创建标题('导出功能示例', 1));
    导出节.addItem(Word.创建段落('这段文本将被导出为HTML和Markdown格式。'));
    导出节.addItem(Word.创建段落('Word模块支持多种格式的导出，方便文档在不同平台间共享。'));
    导出文档.addSection(导出节);
    
    // 导出为HTML
    const html内容 = Word.导出为HTML(导出文档);
    const html路径 = path.join(__dirname, '导出示例.html');
    fs.writeFileSync(html路径, html内容);
    console.log(`文档已导出为HTML: ${html路径}`);
    
    // 导出为Markdown
    const markdown内容 = Word.导出为Markdown(导出文档);
    const markdown路径 = path.join(__dirname, '导出示例.md');
    fs.writeFileSync(markdown路径, markdown内容);
    console.log(`文档已导出为Markdown: ${markdown路径}`);
    
    // ========== 3. 邮件合并模拟 ==========
    console.log('\n3. 邮件合并功能');
    
    // 创建模板文档
    const 模板文档 = Word.创建文档();
    const 模板节 = Word.创建节();
    模板节.addItem(Word.创建标题('邀请函', 1, { alignment: Word.对齐方式.居中 }));
    模板节.addItem(Word.创建段落('', { spacing: { after: 150 } }));
    模板节.addItem(Word.创建段落('尊敬的 {姓名}：'));
    模板节.addItem(Word.创建段落('', { spacing: { after: 100 } }));
    模板节.addItem(Word.创建段落('诚挚邀请您参加我们于 {日期} 在 {地点} 举办的 {活动}。'));
    模板节.addItem(Word.创建段落('', { spacing: { after: 100 } }));
    模板节.addItem(Word.创建段落('期待您的莅临！'));
    模板节.addItem(Word.创建段落('', { spacing: { after: 200 } }));
    模板节.addItem(Word.创建段落('此致'));
    模板节.addItem(Word.创建段落('敬礼'));
    模板文档.addSection(模板节);
    
    // 准备合并数据
    const 合并数据 = [
      { 姓名: '张三', 日期: '2023年12月10日', 地点: '北京国际会议中心', 活动: '技术峰会' },
      { 姓名: '李四', 日期: '2023年12月15日', 地点: '上海展览中心', 活动: '产品发布会' },
      { 姓名: '王五', 日期: '2023年12月20日', 地点: '广州大剧院', 活动: '行业论坛' }
    ];
    
    // 执行邮件合并
    const 合并结果 = Word.创建邮件合并(模板文档, 合并数据);
    console.log(`邮件合并完成，生成 ${合并结果.length} 个文档`);
    
    // ========== 4. 文档保护功能 ==========
    console.log('\n4. 文档保护功能');
    
    // 创建需要保护的文档
    const 保护文档 = Word.创建文档();
    const 保护节 = Word.创建节();
    保护节.addItem(Word.创建标题('机密文档', 1));
    保护节.addItem(Word.创建段落('此文档包含机密信息，请勿外传。'));
    保护文档.addSection(保护节);
    
    // 保护文档
    Word.保护文档(保护文档, 'password123', { 编辑类型: 'readOnly' });
    
    // 保存受保护文档
    const 保护文档路径 = path.join(__dirname, '受保护文档.docx');
    await Word.保存文档到文件(保护文档, 保护文档路径);
    console.log(`受保护文档已保存: ${保护文档路径}`);
    
    // 移除保护（演示）
    Word.移除保护(保护文档);
    
    // ========== 5. 文档压缩功能 ==========
    console.log('\n5. 文档压缩功能');
    
    // 创建一个包含冗余内容的文档
    const 大文档 = Word.创建文档();
    const 大文档节 = Word.创建节();
    
    // 添加一些内容
    大文档节.addItem(Word.创建标题('大文档示例', 1));
    
    // 添加空段落和冗余内容
    for (let i = 0; i < 10; i++) {
      大文档节.addItem(Word.创建段落('')); // 空段落
    }
    
    for (let i = 0; i < 5; i++) {
      大文档节.addItem(Word.创建段落(`这是示例内容 ${i+1}`));
    }
    
    for (let i = 0; i < 10; i++) {
      大文档节.addItem(Word.创建段落('')); // 更多空段落
    }
    
    大文档.addSection(大文档节);
    
    // 压缩文档
    Word.压缩文档(大文档);
    
    // 保存压缩后的文档
    const 压缩文档路径 = path.join(__dirname, '压缩后的文档.docx');
    await Word.保存文档到文件(大文档, 压缩文档路径);
    console.log(`压缩后的文档已保存: ${压缩文档路径}`);
    
    console.log('\n===== 高级功能演示完成 =====');
    
  } catch (错误) {
    console.error('执行高级功能时出错:', 错误);
  }
}

// 执行函数
高级文档功能();
```
#### Excel操作中文封装

**模块信息**
- 模块文件名: index.js
- 路径: zh/后端/xlsx/index.js
- 功能: 提供Excel文件操作的中文API封装，支持Excel文件的读取、创建、修改、数据转换等功能，基于xlsx库实现

**核心特性**
- 完整支持Excel文件的读取、创建、保存和格式转换
- 提供丰富的数据操作API，包括JSON、数组、CSV、TSV等格式转换
- 支持工作表管理、单元格操作、行列操作等核心功能
- 提供样式设置、合并单元格、冻结窗格等高级功能
- 支持Base64转换、文件验证等实用功能
- 保持与原始xlsx库API的功能兼容性，同时提供中文接口

**命令总数：75个**

**核心文件操作** (7个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 读取Excel文件 | 文件路径, 选项 = {} | string, Object | 从Excel文件读取数据 | Object |
| 读取Excel数据 | 数据, 选项 = {} | Buffer\|ArrayBuffer\|Uint8Array\|string, Object | 从内存数据读取Excel | Object |
| 创建工作簿 | 无 | 无 | 创建新的工作簿 | Object |
| 保存工作簿 | 工作簿, 文件路径, 选项 = {} | Object, string, Object | 将工作簿保存到文件 | 无 |
| 工作簿转Buffer | 工作簿, 选项 = {} | Object, Object | 将工作簿转换为Buffer | Buffer |
| 工作簿转Base64 | 工作簿, 文件类型 = 'xlsx' | Object, string | 将工作簿转换为Base64字符串 | string |
| 从Base64读取Excel | base64字符串 | string | 从Base64字符串读取Excel | Object |

**工作簿操作** (8个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取工作表名称列表 | 工作簿 | Object | 获取工作簿中的所有工作表名称 | Array |
| 获取工作表 | 工作簿, 工作表名称 | Object, string | 根据名称获取工作表 | Object\|null |
| 获取第一个工作表 | 工作簿 | Object | 获取第一个工作表 | Object\|null |
| 添加工作表到工作簿 | 工作簿, 工作表, 工作表名称 | Object, Object, string | 将工作表添加到工作簿 | 无 |
| 复制工作表 | 工作簿, 源工作表名称, 目标工作表名称 | Object, string, string | 复制工作表 | Object |
| 删除工作表 | 工作簿, 工作表名称 | Object, string | 删除工作表 | boolean |
| 重命名工作表 | 工作簿, 旧名称, 新名称 | Object, string, string | 重命名工作表 | boolean |
| 克隆工作表 | 工作表 | Object | 克隆工作表 | Object |

**工作表操作** (15个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 创建工作表 | 单元格范围 = '', 单元格对象 = {} | string, Object | 创建工作表 | Object |
| 清除工作表内容 | 工作表 | Object | 清除工作表内容 | 无 |
| 设置单元格值 | 工作表, 单元格地址, 值, 单元格选项 = {} | Object, string, *, Object | 设置单元格值 | 无 |
| 获取单元格值 | 工作表, 单元格地址 | Object, string | 获取单元格值 | * |
| 设置单元格样式 | 工作表, 单元格地址, 样式 | Object, string, Object | 设置单元格样式 | 无 |
| 合并单元格 | 工作表, 范围 | Object, string | 合并单元格 | 无 |
| 设置列宽 | 工作表, 列宽数组 | Object, Array | 设置列宽 | 无 |
| 设置行高 | 工作表, 行高数组 | Object, Array | 设置行高 | 无 |
| 获取工作表范围 | 工作表 | Object | 获取工作表范围 | Object\|null |
| 设置工作表范围 | 工作表, 范围 | Object, string | 设置工作表范围 | 无 |
| 获取使用区域 | 工作表 | Object | 获取工作表的使用区域 | Object |
| 创建带表头工作表 | 表头, 数据 | Array, Array | 创建带有表头的工作表 | Object |
| 获取列标题 | 工作表 | Object | 获取工作表的列标题数组 | Array |
| 冻结窗格 | 工作表, 单元格地址 | Object, string | 冻结窗格 | 无 |
| 自动调整列宽 | 工作表 | Object | 自动调整列宽 | 无 |

**数据转换功能** (10个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| JSON转工作表 | 数据, 选项 = {} | Array, Object | 将JSON数据转换为工作表 | Object |
| 工作表转JSON | 工作表, 选项 = {} | Object, Object | 将工作表转换为JSON数据 | Array |
| 数组转工作表 | 数据, 选项 = {} | Array, Object | 将数组数据转换为工作表 | Object |
| 工作表转数组 | 工作表, 选项 = {} | Object, Object | 将工作表转换为数组 | Array |
| HTML转工作表 | html, 选项 = {} | string, Object | 从HTML表格创建工作表 | Object |
| 工作表转HTML | 工作表, 选项 = {} | Object, Object | 将工作表转换为HTML | string |
| 工作表转CSV | 工作表, 选项 = {} | Object, Object | 将工作表转换为CSV字符串 | string |
| CSV转工作表 | csv, 选项 = {} | string, Object | 将CSV字符串转换为工作表 | Object |
| 工作表转TSV | 工作表, 选项 = {} | Object, Object | 将工作表转换为TSV格式 | string |
| TSV转工作表 | tsv, 选项 = {} | string, Object | 将TSV字符串转换为工作表 | Object |

**单元格操作** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 设置页眉 | 工作表, 页眉内容 | Object, string | 设置页眉 | 无 |
| 设置页脚 | 工作表, 页脚内容 | Object, string | 设置页脚 | 无 |
| 隐藏行 | 工作表, 行号 | Object, number | 隐藏行 | 无 |
| 隐藏列 | 工作表, 列号 | Object, number | 隐藏列 | 无 |
| 保护工作表 | 工作表, 密码 = '', 选项 = {} | Object, string, Object | 保护工作表 | 无 |

**行列操作** (5个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 插入行 | 工作表, 行号, 数据 | Object, number, Array | 插入行 | 无 |
| 删除行 | 工作表, 行号, 数量 = 1 | Object, number, number | 删除行 | 无 |
| 插入列 | 工作表, 列号, 数据 | Object, number, Array | 插入列 | 无 |
| 删除列 | 工作表, 列号, 数量 = 1 | Object, number, number | 删除列 | 无 |
| 追加数据到工作表 | 工作表, 数据 | Object, Array | 将数据追加到工作表末尾 | 无 |

**查找与替换功能** (3个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 查找单元格 | 工作表, 搜索值 | Object, * | 查找单元格 | Array |
| 批量替换单元格 | 工作表, 查找值, 替换值 | Object, *, * | 批量替换单元格值 | number |
| 对比工作表差异 | 工作表1, 工作表2 | Object, Object | 对比两个工作表的差异 | Array |

**辅助功能** (11个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 读取所有工作表 | 文件路径 | string | 批量读取Excel文件中的所有工作表 | Object |
| 保存多工作表Excel | 数据集, 文件路径, 选项 = {} | Object, string, Object | 将多个JSON数据集保存到Excel文件 | 无 |
| 导出到Excel | 数据, 文件路径, 工作表名称 = 'Sheet1' | Array, string, string | 导出数据到Excel文件（简单版本） | 无 |
| 从Excel导入 | 文件路径, 工作表名称 = null | string, string | 从Excel文件导入数据（简单版本） | Array |
| 是有效Excel文件 | 文件路径 | string | 检查文件是否为有效的Excel文件 | boolean |
| 转换Excel格式 | 源文件路径, 目标文件路径, 选项 = {} | string, string, Object | 将Excel文件转换为其他格式 | 无 |
| 获取Excel文件信息 | 文件路径 | string | 获取Excel文件信息 | Object |
| 创建共享字符串表 | 字符串数组 | Array | 创建共享字符串表 | Object |
| 解析单元格地址 | 单元格地址 | string | 获取单元格地址的行列索引 | Object |
| 生成单元格地址 | 行索引, 列索引 | number, number | 根据行列索引生成单元格地址 | string |
| 解析范围 | 范围字符串 | string | 解析范围字符串 | Object |

**常量与获取原始库** (1个)

| 函数名 | 参数 | 参数类型 | 功能描述 | 返回值 |
|-------|-----|---------|--------|-------|
| 获取原始XLSX | 无 | 无 | 获取原始XLSX模块 | Object |

**使用示例**

**CommonJS模块导入:**
```javascript
// 导入xlsx中文操作模块
const xlsx = require('./zh/后端/xlsx/index.js');
const path = require('path');
```

**基本使用示例:**
```javascript
// ========== 1. 创建和保存Excel文件 ==========
async function 创建Excel示例() {
  try {
    // 创建工作簿
    const 工作簿 = xlsx.创建工作簿();
    
    // 准备数据
    const 数据 = [
      { 姓名: '张三', 年龄: 25, 职位: '工程师', 工资: 15000 },
      { 姓名: '李四', 年龄: 30, 职位: '设计师', 工资: 18000 },
      { 姓名: '王五', 年龄: 28, 职位: '产品经理', 工资: 22000 },
      { 姓名: '赵六', 年龄: 35, 职位: '技术总监', 工资: 35000 }
    ];
    
    // 转换数据为工作表
    const 工作表 = xlsx.JSON转工作表(数据);
    
    // 设置列宽
    xlsx.设置列宽(工作表, [
      { wch: 10 }, // 姓名列宽
      { wch: 6 },  // 年龄列宽
      { wch: 12 }, // 职位列宽
      { wch: 10 }  // 工资列宽
    ]);
    
    // 添加工作表到工作簿
    xlsx.添加工作表到工作簿(工作簿, 工作表, '员工信息');
    
    // 保存到文件
    const 文件路径 = path.join(__dirname, '员工信息.xlsx');
    xlsx.保存工作簿(工作簿, 文件路径);
    console.log(`Excel文件已保存到: ${文件路径}`);
    
  } catch (错误) {
    console.error('创建Excel失败:', 错误.message);
  }
}

// ========== 2. 读取和处理Excel文件 ==========
async function 读取Excel示例() {
  try {
    // 读取Excel文件
    const 文件路径 = path.join(__dirname, '员工信息.xlsx');
    const 工作簿 = xlsx.读取Excel文件(文件路径);
    
    // 获取工作表
    const 工作表名称 = xlsx.获取工作表名称列表(工作簿)[0];
    const 工作表 = xlsx.获取工作表(工作簿, 工作表名称);
    
    // 转换为JSON数据
    const 数据 = xlsx.工作表转JSON(工作表);
    console.log('读取到的数据:', 数据);
    
    // 计算平均工资
    const 总工资 = 数据.reduce((sum, 员工) => sum + 员工.工资, 0);
    const 平均工资 = 总工资 / 数据.length;
    console.log(`平均工资: ${平均工资.toFixed(2)}`);
    
  } catch (错误) {
    console.error('读取Excel失败:', 错误.message);
  }
}

// ========== 3. 高级表格操作 ==========
async function 高级表格操作示例() {
  try {
    // 创建工作簿和工作表
    const 工作簿 = xlsx.创建工作簿();
    const 工作表 = xlsx.创建工作表();
    
    // 设置表头
    xlsx.设置单元格值(工作表, 'A1', '产品ID');
    xlsx.设置单元格值(工作表, 'B1', '产品名称');
    xlsx.设置单元格值(工作表, 'C1', '类别');
    xlsx.设置单元格值(工作表, 'D1', '价格');
    xlsx.设置单元格值(工作表, 'E1', '库存');
    
    // 设置表头样式（这里简化处理）
    xlsx.合并单元格(工作表, 'A1:E1');
    
    // 添加产品数据
    const 产品数据 = [
      ['P001', '笔记本电脑', '电子产品', 5999, 45],
      ['P002', '智能手机', '电子产品', 3999, 120],
      ['P003', '无线耳机', '配件', 799, 85],
      ['P004', '智能手表', '可穿戴设备', 1599, 60]
    ];
    
    // 填充数据
    产品数据.forEach((行, 行索引) => {
      行.forEach((值, 列索引) => {
        const 列字母 = String.fromCharCode(65 + 列索引); // A, B, C...
        const 单元格地址 = `${列字母}${行索引 + 2}`; // 从第2行开始
        xlsx.设置单元格值(工作表, 单元格地址, 值);
      });
    });
    
    // 设置列宽
    xlsx.设置列宽(工作表, [
      { wch: 8 },  // 产品ID
      { wch: 15 }, // 产品名称
      { wch: 12 }, // 类别
      { wch: 10 }, // 价格
      { wch: 8 }   // 库存
    ]);
    
    // 冻结窗格
    xlsx.冻结窗格(工作表, 'A2');
    
    // 添加工作表到工作簿
    xlsx.添加工作表到工作簿(工作簿, 工作表, '产品信息');
    
    // 保存文件
    const 文件路径 = path.join(__dirname, '产品信息.xlsx');
    xlsx.保存工作簿(工作簿, 文件路径);
    console.log(`高级表格操作示例已保存到: ${文件路径}`);
    
  } catch (错误) {
    console.error('高级表格操作失败:', 错误.message);
  }
}

// ========== 4. 多工作表操作 ==========
async function 多工作表操作示例() {
  try {
    // 创建工作簿
    const 工作簿 = xlsx.创建工作簿();
    
    // 第一个工作表 - 销售数据
    const 销售数据 = [
      { 月份: '1月', 销售额: 120000, 利润: 35000 },
      { 月份: '2月', 销售额: 145000, 利润: 42000 },
      { 月份: '3月', 销售额: 160000, 利润: 47000 },
      { 月份: '4月', 销售额: 185000, 利润: 54000 }
    ];
    const 销售工作表 = xlsx.JSON转工作表(销售数据);
    xlsx.添加工作表到工作簿(工作簿, 销售工作表, '销售数据');
    
    // 第二个工作表 - 客户信息
    const 客户数据 = [
      { 客户ID: 'C001', 客户名称: 'ABC公司', 联系人: '张三', 电话: '13800138001' },
      { 客户ID: 'C002', 客户名称: 'XYZ企业', 联系人: '李四', 电话: '13900139002' },
      { 客户ID: 'C003', 客户名称: 'DEF集团', 联系人: '王五', 电话: '13700137003' }
    ];
    const 客户工作表 = xlsx.JSON转工作表(客户数据);
    xlsx.添加工作表到工作簿(工作簿, 客户工作表, '客户信息');
    
    // 复制工作表示例
    xlsx.复制工作表(工作簿, '销售数据', '销售数据备份');
    
    // 保存工作簿
    const 文件路径 = path.join(__dirname, '多工作表示例.xlsx');
    xlsx.保存工作簿(工作簿, 文件路径);
    console.log(`多工作表示例已保存到: ${文件路径}`);
    
    // 读取所有工作表
    const 所有工作表数据 = xlsx.读取所有工作表(文件路径);
    console.log('所有工作表数据:', Object.keys(所有工作表数据));
    
  } catch (错误) {
    console.error('多工作表操作失败:', 错误.message);
  }
}

// ========== 5. 数据转换功能 ==========
async function 数据转换示例() {
  try {
    // 创建示例数据
    const json数据 = [
      { 名称: '苹果', 价格: 5.5, 库存: 100 },
      { 名称: '香蕉', 价格: 3.2, 库存: 150 },
      { 名称: '橙子', 价格: 4.8, 库存: 80 }
    ];
    
    // JSON转工作表
    const 工作表 = xlsx.JSON转工作表(json数据);
    
    // 工作表转CSV
    const csv字符串 = xlsx.工作表转CSV(工作表);
    console.log('CSV数据:\n', csv字符串);
    
    // CSV转工作表
    const 从CSV转换的工作表 = xlsx.CSV转工作表(csv字符串);
    
    // 工作表转JSON
    const 转回JSON = xlsx.工作表转JSON(从CSV转换的工作表);
    console.log('转回的JSON数据:', 转回JSON);
    
    // 工作表转数组
    const 数组数据 = xlsx.工作表转数组(工作表);
    console.log('数组数据:', 数组数据);
    
  } catch (错误) {
    console.error('数据转换失败:', 错误.message);
  }
}

// ========== 6. Web服务器中使用 ==========
async function Web服务器使用示例() {
  // 注意：此示例需要在Express等Web服务器环境中运行
  const express = require('express');
  const app = express();
  const fs = require('fs');
  
  app.get('/api/export-excel', async (请求, 响应) => {
    try {
      // 获取数据（这里模拟数据）
      const 数据 = [
        { ID: 1, 姓名: '张三', 部门: '技术部', 入职日期: '2022-01-15' },
        { ID: 2, 姓名: '李四', 部门: '市场部', 入职日期: '2022-03-20' },
        { ID: 3, 姓名: '王五', 部门: '财务部', 入职日期: '2022-05-10' }
      ];
      
      // 创建工作簿和工作表
      const 工作簿 = xlsx.创建工作簿();
      const 工作表 = xlsx.JSON转工作表(数据);
      
      // 添加工作表
      xlsx.添加工作表到工作簿(工作簿, 工作表, '员工数据');
      
      // 转换为Buffer
      const excelBuffer = await xlsx.工作簿转Buffer(工作簿);
      
      // 设置响应头
      响应.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
      响应.setHeader('Content-Disposition', 'attachment; filename=员工数据.xlsx');
      
      // 发送文件
      响应.send(excelBuffer);
      
    } catch (错误) {
      响应.status(500).send({ 错误: 错误.message });
    }
  });
  
  app.post('/api/import-excel', async (请求, 响应) => {
    // 注意：这里需要使用multer等中间件处理文件上传
    // 简化示例，实际使用时需要处理文件上传
    响应.send({ 提示: '文件上传接口示例' });
  });
  
  // 启动服务器
  // app.listen(3000, () => console.log('服务器运行在 http://localhost:3000'));
}

// 执行示例函数
async function 执行示例() {
  console.log('===== 开始执行Excel操作示例 =====');
  
  await 创建Excel示例();
  await 读取Excel示例();
  await 高级表格操作示例();
  await 多工作表操作示例();
  await 数据转换示例();
  
  console.log('===== Excel操作示例执行完成 =====');
}

// 执行函数
执行示例();