E语言字节集数据类型与二进制处理实战

1. E语言字节集数据类型深度解析

字节集是E语言中处理二进制数据的核心数据类型，它本质上是一个有序的字节序列，每个字节的取值范围是0-255（对应一个字节的无符号整数）。在内存中，字节集数据以连续的内存块形式存储，这种特性使其成为处理原始二进制数据的理想选择。

字节集与文本型数据的本质区别在于：文本型数据会自动按照编码规则解释内容，而字节集则直接操作原始二进制值，不做任何解释或转换。

1.1 字节集的内存表示

在32位系统中，一个字节集变量占用16字节内存空间（不考虑实际数据内容）：

• 前4字节：引用计数
• 接着4字节：字节集长度（单位：字节）
• 最后8字节：指向实际数据存储区的指针

这种结构设计使得字节集操作非常高效，特别是在大数据量处理时。例如，当复制一个字节集变量时，实际上只是增加了引用计数，而不会真正复制数据内容，直到发生修改操作（写时复制机制）。

1.2 字节集的常见创建方式

E语言中创建字节集有多种方法，各有适用场景：

e复制.子程序 创建字节集示例
    .局部变量 空字节集, 字节集
    .局部变量 指定长度字节集, 字节集
    .局部变量 从文本转换, 字节集
    .局部变量 直接赋值, 字节集
    .局部变量 拼接字节集, 字节集
    
    ' 方法1：创建空字节集
    空字节集 ＝ {}  ' 长度为0的字节集
    
    ' 方法2：创建指定长度的字节集（所有字节初始化为0）
    指定长度字节集 ＝ 取空白字节集(1024)  ' 创建1KB的空字节集
    
    ' 方法3：从文本转换（使用系统默认编码）
    从文本转换 ＝ 到字节集("Hello, 世界！")
    
    ' 方法4：直接赋值十六进制值
    直接赋值 ＝ {48, 65, 00, 255}  ' 对应ASCII: 0, A, NUL, ÿ
    
    ' 方法5：拼接现有字节集
    拼接字节集 ＝ 直接赋值 ＋ {10, 13}  ' 追加换行符(CRLF)

1.3 字节集的核心操作

字节集支持丰富的操作，以下是实际开发中最常用的几类：

1.3.1 访问与修改

e复制.子程序 字节集访问示例
    .局部变量 数据, 字节集
    .局部变量 长度, 整数型
    .局部变量 首字节, 字节型
    .局部变量 子集, 字节集
    
    数据 ＝ {72, 101, 108, 108, 111}  ' "Hello"的ASCII码
    
    ' 获取字节集长度
    长度 ＝ 取字节集长度(数据)  ' 返回5
    
    ' 访问单个字节（索引从1开始）
    首字节 ＝ 数据[1]  ' 返回72
    
    ' 修改单个字节
    数据[5] ＝ 63  ' 将最后一个字节改为63(对应'?')
    
    ' 提取子集（参数：起始位置，长度）
    子集 ＝ 取字节集中间(数据, 2, 3)  ' 返回{101, 108, 108}
    
    ' 查找字节位置
    位置 ＝ 寻找字节集(数据, {108}, )  ' 返回3

1.3.2 比较与查找

字节集比较是逐字节进行的，常用于数据校验、模式匹配等场景：

e复制.子程序 字节集比较示例
    .局部变量 数据1, 字节集
    .局部变量 数据2, 字节集
    .局部变量 比较结果, 逻辑型
    
    数据1 ＝ {1, 2, 3, 4}
    数据2 ＝ {1, 2, 3, 5}
    
    ' 完全匹配比较
    比较结果 ＝ (数据1 ＝ 数据2)  ' 返回假
    
    ' 部分匹配查找
    位置 ＝ 寻找字节集(数据1, {2, 3}, )  ' 返回2
    
    ' 前缀/后缀检查
    是前缀 ＝ (取字节集中间(数据1, 1, 2) ＝ {1, 2})  ' 返回真

1.3.3 转换与编码

字节集与其他数据类型的转换需要注意编码问题：

e复制.子程序 编码转换示例
    .局部变量 原始文本, 文本型
    .局部变量 字节数据, 字节集
    .局部变量 转换文本, 文本型
    
    原始文本 ＝ "中文测试"
    
    ' 文本到字节集（GBK编码）
    字节数据 ＝ 到字节集(原始文本)  ' 默认使用系统ANSI编码(中文Windows是GBK)
    
    ' 字节集到文本（明确指定编码）
    转换文本 ＝ 编码转换(字节数据, #编码_GBK, #编码_UTF8)
    
    ' 十六进制字符串表示
    十六进制文本 ＝ 字节集到十六进制(字节数据)  ' 如"D6D0CEC4B2E2CAD4"
    
    ' Base64编码
    base64文本 ＝ 字节集到BASE64(字节数据)

2. 文件操作实战指南

2.1 文本文件处理进阶

2.1.1 多编码文本处理

处理不同编码的文本文件时，关键是要正确识别和处理BOM(Byte Order Mark)头：

e复制.子程序 读取多种编码文本
    .参数 文件路径, 文本型
    .局部变量 原始数据, 字节集
    .局部变量 文本内容, 文本型
    
    原始数据 ＝ 读入文件(文件路径)
    
    .判断开始 (取字节集长度(原始数据) ≥ 3 且 取字节集中间(原始数据, 1, 3) ＝ {239, 187, 191})  ' UTF-8 BOM
        文本内容 ＝ 编码转换(取字节集中间(原始数据, 4), #编码_UTF8, #编码_GBK)
    .判断 (取字节集长度(原始数据) ≥ 2 且 取字节集中间(原始数据, 1, 2) ＝ {255, 254})  ' UTF-16 LE BOM
        文本内容 ＝ 编码转换(取字节集中间(原始数据, 3), #编码_UTF16_LE, #编码_GBK)
    .判断 (取字节集长度(原始数据) ≥ 2 且 取字节集中间(原始数据, 1, 2) ＝ {254, 255})  ' UTF-16 BE BOM
        文本内容 ＝ 编码转换(取字节集中间(原始数据, 3), #编码_UTF16_BE, #编码_GBK)
    .默认
        ' 无BOM头，尝试按系统默认编码(GBK)解析
        文本内容 ＝ 到文本(原始数据)
    .判断结束
    
    返回 文本内容

2.1.2 大文本文件分块处理

处理大文本文件时，应避免一次性读取全部内容：

e复制.子程序 分块读取大文件
    .参数 文件路径, 文本型
    .局部变量 文件句柄, 整数型
    .局部变量 缓冲区, 字节集
    .局部变量 块大小, 整数型
    .局部变量 总大小, 整数型
    .局部变量 已读, 整数型
    
    块大小 ＝ 1024 × 1024  ' 1MB缓冲区
    文件句柄 ＝ 打开文件(文件路径, #读入, )
    总大小 ＝ 取文件长度(文件句柄)
    已读 ＝ 0
    
    .判断循环首 (已读 ＜ 总大小)
        ' 计算本次读取大小（不超过剩余字节数）
        .局部变量 本次读取大小, 整数型
        本次读取大小 ＝ 选择(总大小 - 已读 ＞ 块大小, 块大小, 总大小 - 已读)
        
        缓冲区 ＝ 读入字节集(文件句柄, 本次读取大小)
        已读 ＝ 已读 ＋ 本次读取大小
        
        ' 处理当前数据块（示例：查找特定字符串）
        .局部变量 文本块, 文本型
        文本块 ＝ 到文本(缓冲区)
        
        ' ...执行实际处理...
    .判断循环尾 ()
    
    关闭文件(文件句柄)

2.2 二进制文件操作精要

2.2.1 PE文件结构解析

PE(Portable Executable)是Windows可执行文件格式，通过字节集可以解析其基本结构：

e复制.子程序 解析PE文件
    .参数 文件路径, 文本型
    .局部变量 文件数据, 字节集
    .局部变量 dos头, 字节集
    .局部变量 pe偏移, 整数型
    .局部变量 pe头, 字节集
    .局部变量 节表, 字节集
    
    文件数据 ＝ 读入文件(文件路径)
    
    ' 检查DOS头（前64字节）
    .如果 (取字节集长度(文件数据) ＜ 64)
        返回 "文件太小，不是有效的PE文件"
    .否则
        dos头 ＝ 取字节集中间(文件数据, 1, 64)
    .如果结束
    
    ' 检查DOS签名"MZ"
    .如果 (取字节集中间(dos头, 1, 2) ≠ {77, 90})  ' "MZ"
        返回 "无效的DOS头签名"
    .如果结束
    
    ' 获取PE头偏移（DOS头中0x3C处）
    pe偏移 ＝ 取字节集数据(取字节集中间(dos头, 61, 4), #整数型)
    
    ' 检查PE头
    .如果 (取字节集长度(文件数据) ＜ pe偏移 + 24)
        返回 "PE头位置超出文件范围"
    .否则
        pe头 ＝ 取字节集中间(文件数据, pe偏移 + 1, 24)
    .如果结束
    
    ' 检查PE签名"PE\0\0"
    .如果 (取字节集中间(pe头, 1, 4) ≠ {80, 69, 0, 0})
        返回 "无效的PE签名"
    .如果结束
    
    ' 获取节表信息
    .局部变量 节数, 整数型
    .局部变量 节表偏移, 整数型
    节数 ＝ 取字节集数据(取字节集中间(pe头, 7, 2), #短整数型)
    节表偏移 ＝ pe偏移 + 24 + 取字节集数据(取字节集中间(pe头, 21, 2), #短整数型)
    
    ' 返回解析结果
    返回 "PE文件有效，共" ＋ 到文本(节数) ＋ "个节"

2.2.2 二进制补丁制作

字节集操作非常适合制作文件补丁：

e复制.子程序 应用补丁
    .参数 原始文件, 文本型
    .参数 补丁文件, 文本型
    .参数 补丁列表, 补丁信息, 数组
    .局部变量 文件数据, 字节集
    
    文件数据 ＝ 读入文件(原始文件)
    
    .计次循环首 (取数组成员数(补丁列表), i)
        .局部变量 补丁, 补丁信息
        补丁 ＝ 补丁列表[i]
        
        ' 检查偏移是否有效
        .如果 (补丁.偏移 ＋ 取字节集长度(补丁.新数据) － 1 ＞ 取字节集长度(文件数据))
            输出调试文本("补丁" ＋ 到文本(i) ＋ "偏移超出范围")
            到循环尾 ()
        .如果结束
        
        ' 应用补丁
        文件数据 ＝ 取字节集中间(文件数据, 1, 补丁.偏移 - 1) ＋ 
                  补丁.新数据 ＋ 
                  取字节集中间(文件数据, 补丁.偏移 ＋ 取字节集长度(补丁.新数据))
    .计次循环尾 ()
    
    ' 保存修改后的文件
    写到文件(补丁文件, 文件数据)
    
    .数据类型 补丁信息
        .成员 偏移, 整数型  ' 从1开始的位置
        .成员 新数据, 字节集

3. 网络通信中的字节集应用

3.1 自定义协议设计与实现

3.1.1 协议帧结构设计

一个典型的自定义协议帧可以这样设计：

code复制+--------+--------+--------+--------+----------------+
|  魔数  | 版本号 | 命令字 | 长度   |     数据       |
| 4字节  | 1字节  | 1字节  | 2字节  |   N字节        |
+--------+--------+--------+--------+----------------+

对应实现代码：

e复制.子程序 构建协议帧
    .参数 命令, 字节型
    .参数 数据, 字节集
    .局部变量 帧数据, 字节集
    
    ' 魔数(固定值0x12345678)
    帧数据 ＝ {0x12, 0x34, 0x56, 0x78}
    
    ' 协议版本(1)
    帧数据 ＝ 帧数据 ＋ {1}
    
    ' 命令字
    帧数据 ＝ 帧数据 ＋ {命令}
    
    ' 数据长度(2字节，小端序)
    帧数据 ＝ 帧数据 ＋ 到字节集(取字节集长度(数据), #短整数型)
    
    ' 有效载荷
    帧数据 ＝ 帧数据 ＋ 数据
    
    ' 计算并附加CRC32校验(后4字节)
    帧数据 ＝ 帧数据 ＋ 取数据校验(帧数据)
    
    返回 帧数据

3.1.2 协议解析实现

e复制.子程序 解析协议帧
    .参数 帧数据, 字节集
    .局部变量 结果, 协议帧
    
    ' 检查最小长度(魔数4+版本1+命令1+长度2+CRC4=12字节)
    .如果 (取字节集长度(帧数据) ＜ 12)
        返回 结果  ' 返回空结构
    .如果结束
    
    ' 检查魔数
    .如果 (取字节集中间(帧数据, 1, 4) ≠ {0x12, 0x34, 0x56, 0x78})
        返回 结果
    .如果结束
    
    ' 提取基本信息
    结果.版本 ＝ 帧数据[5]
    结果.命令 ＝ 帧数据[6]
    结果.长度 ＝ 取字节集数据(取字节集中间(帧数据, 7, 2), #短整数型)
    
    ' 检查数据长度
    .如果 (取字节集长度(帧数据) ≠ 12 + 结果.长度)
        返回 结果
    .如果结束
    
    ' 提取数据
    结果.数据 ＝ 取字节集中间(帧数据, 9, 结果.长度)
    
    ' 验证CRC
    .局部变量 计算CRC, 字节集
    .局部变量 帧CRC, 字节集
    计算CRC ＝ 取数据校验(取字节集中间(帧数据, 1, 8 + 结果.长度))
    帧CRC ＝ 取字节集中间(帧数据, 9 + 结果.长度, 4)
    
    .如果 (计算CRC ≠ 帧CRC)
        返回 结果
    .如果结束
    
    结果.有效 ＝ 真
    返回 结果
    
    .数据类型 协议帧
        .成员 版本, 字节型
        .成员 命令, 字节型
        .成员 长度, 短整数型
        .成员 数据, 字节集
        .成员 有效, 逻辑型

3.2 高效数据分片传输

大文件分片传输的典型实现：

e复制.子程序 发送文件分片
    .参数 文件路径, 文本型
    .参数 分片大小, 整数型, 可空, 默认1MB
    .局部变量 文件句柄, 整数型
    .局部变量 文件大小, 整数型
    .局部变量 已发送, 整数型
    .局部变量 分片编号, 整数型
    
    .如果 (是否为空(分片大小))
        分片大小 ＝ 1024 × 1024
    .如果结束
    
    文件句柄 ＝ 打开文件(文件路径, #读入, )
    文件大小 ＝ 取文件长度(文件句柄)
    已发送 ＝ 0
    分片编号 ＝ 0
    
    .判断循环首 (已发送 ＜ 文件大小)
        分片编号 ＝ 分片编号 ＋ 1
        .局部变量 当前分片大小, 整数型
        当前分片大小 ＝ 选择(文件大小 - 已发送 ＞ 分片大小, 分片大小, 文件大小 - 已发送)
        
        .局部变量 分片数据, 字节集
        分片数据 ＝ 读入字节集(文件句柄, 当前分片大小)
        已发送 ＝ 已发送 ＋ 当前分片大小
        
        ' 构建分片协议帧
        .局部变量 帧头, 字节集
        帧头 ＝ 到字节集(分片编号) ＋ 到字节集(已发送 ＝ 文件大小)  ' 分片编号(4字节) + 是否结束标志(1字节)
        
        .局部变量 协议帧, 字节集
        协议帧 ＝ 构建协议帧(#命令_文件分片, 帧头 ＋ 分片数据)
        
        ' 发送协议帧（实际网络发送代码略）
        发送数据(协议帧)
        
        ' 更新进度（每完成5%或最后一个分片时报告）
        .如果 (已发送 ＝ 文件大小 或 (已发送 × 100 \ 文件大小) ＞ ((已发送 - 当前分片大小) × 100 \ 文件大小 ＋ 5))
            输出调试文本("已发送：" ＋ 到文本(已发送 × 100 \ 文件大小) ＋ "%")
        .如果结束
    .判断循环尾 ()
    
    关闭文件(文件句柄)

4. 多媒体数据处理技巧

4.1 图像处理实战

4.1.1 BMP位图解析

BMP是最简单的图像格式之一，适合用字节集操作：

e复制.子程序 解析BMP文件
    .参数 文件路径, 文本型
    .局部变量 文件数据, 字节集
    .局部变量 文件头, 字节集
    .局部变量 信息头, 字节集
    .局部变量 宽度, 整数型
    .局部变量 高度, 整数型
    .局部变量 位深度, 短整数型
    .局部变量 像素数据偏移, 整数型
    
    文件数据 ＝ 读入文件(文件路径)
    
    ' 检查基本长度
    .如果 (取字节集长度(文件数据) ＜ 54)
        返回 "文件太小，不是有效的BMP"
    .如果结束
    
    ' 检查文件头签名"BM"
    文件头 ＝ 取字节集中间(文件数据, 1, 14)
    .如果 (取字节集中间(文件头, 1, 2) ≠ {66, 77})  ' "BM"
        返回 "无效的BMP文件头"
    .如果结束
    
    ' 解析信息头(从第15字节开始40字节)
    信息头 ＝ 取字节集中间(文件数据, 15, 40)
    宽度 ＝ 取字节集数据(取字节集中间(信息头, 5, 4), #整数型)
    高度 ＝ 取字节集数据(取字节集中间(信息头, 9, 4), #整数型)
    位深度 ＝ 取字节集数据(取字节集中间(信息头, 15, 2), #短整数型)
    像素数据偏移 ＝ 取字节集数据(取字节集中间(文件头, 11, 4), #整数型)
    
    ' 检查位深度支持(仅处理24位RGB)
    .如果 (位深度 ≠ 24)
        返回 "仅支持24位BMP图像"
    .如果结束
    
    ' 提取像素数据
    .局部变量 行字节数, 整数型
    .局部变量 填充字节, 整数型
    行字节数 ＝ 宽度 × 3
    填充字节 ＝ (4 - (行字节数 ％ 4)) ％ 4  ' BMP每行按4字节对齐
    
    .局部变量 像素数据, 字节集
    像素数据 ＝ 取字节集中间(文件数据, 像素数据偏移 + 1)
    
    ' 返回解析结果
    返回 "BMP图像：" ＋ 到文本(宽度) ＋ "x" ＋ 到文本(高度) ＋ "，位深度：" ＋ 到文本(位深度)

4.1.2 简单图像处理

实现灰度化处理的示例：

e复制.子程序 图像灰度化
    .参数 原始数据, 字节集
    .参数 宽度, 整数型
    .参数 高度, 整数型
    .局部变量 结果数据, 字节集
    .局部变量 行字节数, 整数型
    .局部变量 填充字节, 整数型
    .局部变量 偏移, 整数型
    
    行字节数 ＝ 宽度 × 3
    填充字节 ＝ (4 - (行字节数 ％ 4)) ％ 4
    结果数据 ＝ 原始数据
    
    .计次循环首 (高度, y)
        .计次循环首 (宽度, x)
            偏移 ＝ (y - 1) × (行字节数 + 填充字节) + (x - 1) × 3 + 1
            
            ' 获取BGR分量（注意BMP存储顺序是BGR）
            .局部变量 b, 字节型
            .局部变量 g, 字节型
            .局部变量 r, 字节型
            b ＝ 原始数据[偏移]
            g ＝ 原始数据[偏移 + 1]
            r ＝ 原始数据[偏移 + 2]
            
            ' 计算灰度值（加权平均法）
            .局部变量 灰度, 字节型
            灰度 ＝ (r × 30 + g × 59 + b × 11) \ 100
            
            ' 设置灰度值
            结果数据[偏移] ＝ 灰度
            结果数据[偏移 + 1] ＝ 灰度
            结果数据[偏移 + 2] ＝ 灰度
        .计次循环尾 ()
    .计次循环尾 ()
    
    返回 结果数据

4.2 WAV音频文件处理

4.2.1 WAV文件头解析

e复制.子程序 解析WAV文件
    .参数 文件路径, 文本型
    .局部变量 文件数据, 字节集
    .局部变量 riff头, 字节集
    .局部变量 fmt块, 字节集
    .局部变量 数据块, 字节集
    
    文件数据 ＝ 读入文件(文件路径)
    
    ' 检查RIFF头
    .如果 (取字节集长度(文件数据) ＜ 12)
        返回 "文件太小，不是有效的WAV"
    .如果结束
    
    riff头 ＝ 取字节集中间(文件数据, 1, 12)
    .如果 (取字节集中间(riff头, 1, 4) ≠ {82, 73, 70, 70})  ' "RIFF"
        返回 "无效的WAV文件头"
    .如果结束
    
    ' 查找"fmt "块(不一定在固定位置)
    .局部变量 位置, 整数型
    位置 ＝ 寻找字节集(文件数据, {102, 109, 116, 32}, )  ' "fmt "
    .如果 (位置 ＝ -1)
        返回 "找不到fmt块"
    .如果结束
    
    ' 解析fmt块(从"fmt "后开始)
    fmt块 ＝ 取字节集中间(文件数据, 位置 + 4, 16)
    .局部变量 音频格式, 短整数型
    .局部变量 声道数, 短整数型
    .局部变量 采样率, 整数型
    .局部变量 字节率, 整数型
    .局部变量 块对齐, 短整数型
    .局部变量 位深度, 短整数型
    
    音频格式 ＝ 取字节集数据(取字节集中间(fmt块, 1, 2), #短整数型)
    声道数 ＝ 取字节集数据(取字节集中间(fmt块, 3, 2), #短整数型)
    采样率 ＝ 取字节集数据(取字节集中间(fmt块, 5, 4), #整数型)
    字节率 ＝ 取字节集数据(取字节集中间(fmt块, 9, 4), #整数型)
    块对齐 ＝ 取字节集数据(取字节集中间(fmt块, 13, 2), #短整数型)
    位深度 ＝ 取字节集数据(取字节集中间(fmt块, 15, 2), #短整数型)
    
    ' 查找"data"块
    位置 ＝ 寻找字节集(文件数据, {100, 97, 116, 97}, )  ' "data"
    .如果 (位置 ＝ -1)
        返回 "找不到数据块"
    .如果结束
    
    ' 返回解析结果
    返回 "WAV格式：" ＋ 选择(音频格式 ＝ 1, "PCM", "压缩") ＋ "，" ＋ 
         到文本(声道数) ＋ "声道，" ＋ 
         到文本(采样率) ＋ "Hz，" ＋ 
         到文本(位深度) ＋ "位"

4.2.2 音频音量调整

e复制.子程序 调整WAV音量
    .参数 原始数据, 字节集
    .参数 数据偏移, 整数型
    .参数 数据长度, 整数型
    .参数 声道数, 短整数型
    .参数 位深度, 短整数型
    .参数 音量比例, 小数型
    .局部变量 结果数据, 字节集
    .局部变量 样本大小, 整数型
    .局部变量 样本数, 整数型
    .局部变量 i, 整数型
    
    结果数据 ＝ 原始数据
    样本大小 ＝ 位深度 \ 8
    样本数 ＝ 数据长度 \ (声道数 × 样本大小)
    
    ' 仅处理16位PCM
    .如果 (位深度 ≠ 16)
        返回 原始数据
    .如果结束
    
    .计次循环首 (样本数, i)
        .局部变量 样本偏移, 整数型
        样本偏移 ＝ 数据偏移 + (i - 1) × 声道数 × 样本大小
        
        .局部变量 左声道, 短整数型
        .局部变量 右声道, 短整数型
        左声道 ＝ 取字节集数据(取字节集中间(原始数据, 样本偏移 + 1, 2), #短整数型)
        
        ' 调整左声道音量
        左声道 ＝ 左声道 × 音量比例
        .如果 (左声道 ＞ 32767)
            左声道 ＝ 32767
        .否则
            .如果 (左声道 ＜ -32768)
                左声道 ＝ -32768
            .如果结束
        .如果结束
        
        ' 更新数据
        结果数据 ＝ 替换字节集中间(结果数据, 样本偏移 + 1, 2, 到字节集(左声道))
        
        ' 如果是立体声，处理右声道
        .如果 (声道数 ≥ 2)
            右声道 ＝ 取字节集数据(取字节集中间(原始数据, 样本偏移 + 3, 2), #短整数型)
            右声道 ＝ 右声道 × 音量比例
            .如果 (右声道 ＞ 32767)
                右声道 ＝ 32767
            .否则
                .如果 (右声道 ＜ -32768)
                    右声道 ＝ -32768
                .如果结束
            .如果结束
            
            结果数据 ＝ 替换字节集中间(结果数据, 样本偏移 + 3, 2, 到字节集(右声道))
        .如果结束
    .计次循环尾 ()
    
    返回 结果数据

5. 加密与安全实践

5.1 AES加密实现

e复制.子程序 AES加密
    .参数 原始数据, 字节集
    .参数 密钥, 字节集
    .参数 iv, 字节集, 可空
    .局部变量 加密结果, 字节集
    .局部变量 填充方式, 整数型
    .局部变量 加密模式, 整数型
    
    ' 检查密钥长度(支持128/192/256位)
    .局部变量 密钥长度, 整数型
    密钥长度 ＝ 取字节集长度(密钥)
    .如果 (密钥长度 ≠ 16 且 密钥长度 ≠ 24 且 密钥长度 ≠ 32)
        返回 {}  ' 无效密钥长度
    .如果结束
    
    ' 设置默认IV(全零)
    .如果 (是否为空(iv))
        iv ＝ 取空白字节集(16)
    .否则
        .如果 (取字节集长度(iv) ≠ 16)
            返回 {}  ' IV必须是16字节
        .如果结束
    .如果结束
    
    ' 使用CBC模式，PKCS7填充
    填充方式 ＝ #填充方式_PKCS7
    加密模式 ＝ #对称加密_CBC
    
    ' 执行加密
    加密结果 ＝ 对称加密(原始数据, 密钥, iv, #算法_AES, 加密模式, 填充方式)
    
    返回 加密结果

5.2 安全哈希计算

e复制.子程序 计算安全哈希
    .参数 数据, 字节集
    .参数 算法, 整数型, 可空  ' #哈希算法_SHA256等
    .参数 加盐, 字节集, 可空
    .局部变量 哈希结果, 字节集
    
    .如果 (是否为空(算法))
        算法 ＝ #哈希算法_SHA256
    .如果结束
    
    ' 加盐处理
    .如果 (是否为空(加盐) ＝ 假)
        数据 ＝ 加盐 ＋ 数据
    .如果结束
    
    ' 计算哈希
    哈希结果 ＝ 取数据摘要(数据, 算法)
    
    ' 多次迭代增强安全性
    .局部变量 i, 整数型
    .计次循环首 (1000, i)
        哈希结果 ＝ 取数据摘要(哈希结果 ＋ 数据, 算法)
    .计次循环尾 ()
    
    返回 哈希结果

6. 性能优化与调试技巧

6.1 字节集操作性能优化

1. 预分配内存：对于已知大小的字节集，预先分配足够空间

e复制.子程序 高效字节集操作
    .局部变量 大数据, 字节集
    .局部变量 结果, 字节集
    .局部变量 i, 整数型
    
    ' 错误方式：不断拼接（每次都会重新分配内存）
    结果 ＝ {}
    .计次循环首 (100000, i)
        结果 ＝ 结果 ＋ {i ％ 256}  ' 性能极差
    .计次循环尾 ()
    
    ' 正确方式：预分配空间
    结果 ＝ 取空白字节集(100000)
    .计次循环首 (100000, i)
        结果[i] ＝ i ％ 256  ' 直接修改指定位置
    .计次循环尾 ()

2. 批量操作：尽量减少单个字节的修改，使用子集替换

e复制.子程序 批量替换示例
    .参数 原始数据, 字节集
    .参数 查找序列, 字节集
    .参数 替换序列, 字节集
    .局部变量 位置, 整数型
    .局部变量 结果, 字节集
    
    结果 ＝ 原始数据
    位置 ＝ 寻找字节集(结果, 查找序列, )
    
    .判断循环首 (位置 ≠ -1)
        ' 一次性替换整个序列，而不是逐个字节修改
        结果 ＝ 取字节集中间(结果, 1, 位置 - 1) ＋ 
              替换序列 ＋ 
              取字节集中间(结果, 位置 + 取字节集长度(查找序列))
        
        位置 ＝ 寻找字节集(结果, 查找序列, 位置 + 取字节集长度(替换序列))
    .判断循环尾 ()
    
    返回 结果

6.2 常见问题排查

1. 字节序问题：

   • 网络传输和文件存储中要注意字节序(大端/小端)
   • 使用反转字节序函数处理跨平台数据

2. 编码问题：

   • 文本与字节集转换时明确指定编码
   • 处理UTF-8时注意BOM头

3. 内存不足：

   • 大文件处理要分块进行
   • 及时释放不再使用的字节集变量

4. 调试技巧：

   • 使用字节集到十六进制查看原始数据
   • 对比预期和实际的字节集差异

e复制.子程序 比较字节集差异
    .参数 预期, 字节集
    .参数 实际, 字节集
    .局部变量 i, 整数型
    .局部变量 差异位置, 整数型, 数组
    
    .如果 (取字节集长度(预期) ≠ 取字节集长度(实际))
        输出调试文本("长度不同：预期" ＋ 到文本(取字节集长度(预期)) ＋ "，实际" ＋ 到文本(取字节集长度(实际)))
        返回
    .如果结束
    
    .计次循环首 (取字节集长度(预期), i)
        .如果 (预期[i] ≠ 实际[i])
            加入成员(差异位置, i)
        .如果结束
    .计次循环尾 ()
    
    .如果 (取数组成员数(差异位置) ＝ 0)
        输出调试文本("字节集完全相同")
    .否则
        输出调试文本("发现" ＋ 到文本(取数组成员数(差异位置)) ＋ "处差异，首处位置：" ＋ 到文本(差异位置[1]))
    .如果结束

7. 实际项目经验分享

7.1 配置文件加密方案

在真实项目中，我采用以下方案保护敏感配置：

e复制.子程序 安全读写配置
    .参数 文件路径, 文本型
    .参数 是否写入, 逻辑型, 可空
    .参数 配置数据, 文本型, 可空, 写入时使用
    .局部变量 密钥, 字节集
    .局部变量 iv, 字节集