基础模块-字节集示例51-60

qq1073176068 · 发表于 2025-9-28 08:33:39

本帖最后由 qq1073176068 于 2025-9-29 20:44 编辑

51.置文本A

// 示例：重置字节集为ANSI文本
// 炫语言：定义字节集并添加初始数据
字节集数据集
数据集.添加文本("Hello", 假)
// 炫语言：输出重置前的状态
调试输出("重置前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置前十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 重置前字节集大小：10字节
// 重置前十六进制内容：48 00 65 00 6C 00 6C 00 6F 00

复制代码

// 炫语言：重置为ANSI文本"你好炫语言"
数据集.置文本A(A"你好炫语言")
// 炫语言：输出重置后的状态
调试输出("重置后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置后文本内容：" + A2W(数据集.取文本A(0, 10)))
调试输出("重置后十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 重置后字节集大小：10字节
// 重置后文本内容：你好炫语言
// 重置后十六进制内容：C4 E3 BA C3 D0 FE D3 EF D1 D4
// 字节解析：C4 E3='你'、BA C3='好'、D0 FE='炫'、D3 EF='语'、D1 D4='言'（GBK编码）

复制代码

--
52.置十六进制文本

// 示例：重置字节集为十六进制文本
// 炫语言：定义字节集并添加初始数据
字节集数据集
数据集.添加文本A(A"Hello", 假)
// 炫语言：输出重置前的状态
调试输出("重置前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置前十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 重置前字节集大小：5字节
// 重置前十六进制内容：48 65 6C 6C 6F

复制代码

// 炫语言：重置为十六进制文本"48656C6C6F"（对应"Hello"）
数据集.置十六进制文本("48656C6C6F")
// 炫语言：输出重置后的状态
调试输出("重置后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置后文本内容：" + A2W(数据集.取文本A(0, 5)))
调试输出("重置后十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 重置后字节集大小：5字节
// 重置后文本内容：Hello
// 重置后十六进制内容：48 65 6C 6C 6F
// 字节解析：48='H'、65='e'、6C='l'、6C='l'、6F='o'
// 炫语言：重置为中文的十六进制文本
数据集.置十六进制文本("C4E3BAC3") // "你好"的GBK编码
// 炫语言：输出再次重置后的状态
调试输出("再次重置后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("再次重置后文本内容：" + A2W(数据集.取文本A(0, 4)))
调试输出("再次重置后十六进制内容：")
调试输出十六进制((常量字符型A*)数据集.取地址(), 数据集.取大小())
// 输出结果：
// 再次重置后字节集大小：4字节
// 再次重置后文本内容：你好
// 再次重置后十六进制内容：C4 E3 BA C3
// 字节解析：C4 E3='你'、BA C3='好'（GBK编码）

复制代码

--
53.取左边

// 示例：从字节集左边取指定长度数据
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello World", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：11字节
// 原始十六进制内容：48 65 6C 6C 6F 20 57 6F 72 6C 64
// 炫语言：从左边取5字节数据
字节集左边数据 = 原数据集.取左边(5)
调试输出("左边5字节数据大小：" + 到文本(左边数据.取大小()) + "字节")
调试输出("左边5字节文本内容：" + A2W(左边数据.取文本A(0, 5)))
调试输出("左边5字节十六进制内容：")
调试输出十六进制((常量字符型A*)左边数据.取地址(), 左边数据.取大小())
// 输出结果：
// 左边5字节数据大小：5字节
// 左边5字节文本内容：Hello
// 左边5字节十六进制内容：48 65 6C 6C 6F

复制代码

// 炫语言：从左边取8字节数据
字节集左边数据2 = 原数据集.取左边(8)
调试输出("左边8字节数据大小：" + 到文本(左边数据2.取大小()) + "字节")
调试输出("左边8字节文本内容：" + A2W(左边数据2.取文本A(0, 8)))
调试输出("左边8字节十六进制内容：")
调试输出十六进制((常量字符型A*)左边数据2.取地址(), 左边数据2.取大小())
// 输出结果：
// 左边8字节数据大小：8字节
// 左边8字节文本内容：Hello Wo
// 左边8字节十六进制内容：48 65 6C 6C 6F 20 57 6F

复制代码

--
54.取右边

// 示例：从字节集右边取指定长度数据
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello World", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：11字节
// 原始十六进制内容：48 65 6C 6C 6F 20 57 6F 72 6C 64
// 炫语言：从右边取5字节数据
字节集右边数据 = 原数据集.取右边(5)
调试输出("右边5字节数据大小：" + 到文本(右边数据.取大小()) + "字节")
调试输出("右边5字节文本内容：" + A2W(右边数据.取文本A(0, 5)))
调试输出("右边5字节十六进制内容：")
调试输出十六进制((常量字符型A*)右边数据.取地址(), 右边数据.取大小())
// 输出结果：
// 右边5字节数据大小：5字节
// 右边5字节文本内容：World
// 右边5字节十六进制内容：57 6F 72 6C 64
// 炫语言：从右边取8字节数据
字节集右边数据2 = 原数据集.取右边(8)
调试输出("右边8字节数据大小：" + 到文本(右边数据2.取大小()) + "字节")
调试输出("右边8字节文本内容：" + A2W(右边数据2.取文本A(0, 8)))
调试输出("右边8字节十六进制内容：")
调试输出十六进制((常量字符型A*)右边数据2.取地址(), 右边数据2.取大小())
// 输出结果：
// 右边8字节数据大小：8字节
// 右边8字节文本内容：lo World
// 右边8字节十六进制内容：6C 6F 20 57 6F 72 6C 64

复制代码

--
55.取中间

// 示例：从字节集中间取指定位置和长度的数据
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello World", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：11字节
// 原始十六进制内容：48 65 6C 6C 6F 20 57 6F 72 6C 64
// 炫语言：从位置6开始取5字节数据
字节集中间数据 = 原数据集.取中间(6, 5)
调试输出("位置6开始取5字节数据大小：" + 到文本(中间数据.取大小()) + "字节")
调试输出("中间数据文本内容：" + A2W(中间数据.取文本A(0, 5)))
调试输出("中间数据十六进制内容：")
调试输出十六进制((常量字符型A*)中间数据.取地址(), 中间数据.取大小())
// 输出结果：
// 位置6开始取5字节数据大小：5字节
// 中间数据文本内容：World
// 中间数据十六进制内容：57 6F 72 6C 64
// 炫语言：从位置2开始取7字节数据
字节集中间数据2 = 原数据集.取中间(2, 7)
调试输出("位置2开始取7字节数据大小：" + 到文本(中间数据2.取大小()) + "字节")
调试输出("中间数据2文本内容：" + A2W(中间数据2.取文本A(0, 7)))
调试输出("中间数据2十六进制内容：")
调试输出十六进制((常量字符型A*)中间数据2.取地址(), 中间数据2.取大小())
// 输出结果：
// 位置2开始取7字节数据大小：7字节
// 中间数据2文本内容：llo Wor
// 中间数据2十六进制内容：6C 6C 6F 20 57 6F 72

复制代码

--
56.到十六进制字节集

// 示例：将字节集数据转换为十六进制字节集
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：5字节
// 原始十六进制内容：
// 48 65 6C 6C 6F
// 炫语言：转换为十六进制字节集（大写，不分割）
字节集十六进制数据 = 原数据集.到十六进制字节集(真, 假)
调试输出("十六进制字节集大小：" + 到文本(十六进制数据.取大小()) + "字节")
调试输出("十六进制文本内容：")
调试输出十六进制((常量字符型A*)十六进制数据.取地址(), 十六进制数据.取大小())
// 输出结果：
// 十六进制字节集大小：20字节
// 十六进制文本内容：
// 34 00 38 00 36 00 35 00 36 00 43 00 36 00 43 00 36 00 46 00
// 字节解析：Unicode编码的"48656C6C6F"，每个字符占2字节
// 炫语言：转换为十六进制字节集（大写，分割）
字节集十六进制数据2 = 原数据集.到十六进制字节集(真, 真)
调试输出("带分割的十六进制字节集大小：" + 到文本(十六进制数据2.取大小()) + "字节")
调试输出("带分割的十六进制文本内容：")
调试输出十六进制((常量字符型A*)十六进制数据2.取地址(), 十六进制数据2.取大小())
// 输出结果：
// 带分割的十六进制字节集大小：28字节
// 带分割的十六进制文本内容：
// 34 00 38 00 20 00 36 00 35 00 20 00 36 00 43 00 20 00 36 00 43 00 20 00 36 00 46 00
// 字节解析：Unicode编码的"48 65 6C 6C 6F"，包含空格分隔符
// 炫语言：转换为十六进制字节集（小写，分割）
字节集十六进制数据3 = 原数据集.到十六进制字节集(假, 真)
调试输出("小写带分割的十六进制字节集大小：" + 到文本(十六进制数据3.取大小()) + "字节")
调试输出("小写带分割的十六进制文本内容：")
调试输出十六进制((常量字符型A*)十六进制数据3.取地址(), 十六进制数据3.取大小())
// 输出结果：
// 小写带分割的十六进制字节集大小：28字节
// 小写带分割的十六进制文本内容：
// 34 00 38 00 20 00 36 00 35 00 20 00 36 00 63 00 20 00 36 00 63 00 20 00 36 00 66 00
// 字节解析：Unicode编码的"48 65 6c 6c 6f"，小写字母，包含空格分隔符

复制代码

--
57.到十六进制字节集A

// 示例：将字节集数据转换为ANSI十六进制字节集
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：5字节
// 原始十六进制内容：
// 48 65 6C 6C 6F
// 炫语言：转换为ANSI十六进制字节集（大写，不分割）
字节集十六进制数据 = 原数据集.到十六进制字节集A(真, 假)
调试输出("ANSI十六进制字节集大小：" + 到文本(十六进制数据.取大小()) + "字节")
调试输出("ANSI十六进制文本内容：" + A2W(十六进制数据.取文本A(0, 十六进制数据.取大小())))
// 输出结果：
// ANSI十六进制字节集大小：10字节
// ANSI十六进制文本内容：48656C6C6F
// 炫语言：转换为ANSI十六进制字节集（大写，分割）
字节集十六进制数据2 = 原数据集.到十六进制字节集A(真, 真)
调试输出("ANSI带分割的十六进制字节集大小：" + 到文本(十六进制数据2.取大小()) + "字节")
调试输出("ANSI带分割的十六进制文本内容：" + A2W(十六进制数据2.取文本A(0, 十六进制数据2.取大小())))
// 输出结果：
// ANSI带分割的十六进制字节集大小：14字节
// ANSI带分割的十六进制文本内容：48 65 6C 6C 6F
// 炫语言：转换为ANSI十六进制字节集（小写，分割）
字节集十六进制数据3 = 原数据集.到十六进制字节集A(假, 真)
调试输出("ANSI小写带分割的十六进制字节集大小：" + 到文本(十六进制数据3.取大小()) + "字节")
调试输出("ANSI小写带分割的十六进制文本内容：" + A2W(十六进制数据3.取文本A(0, 十六进制数据3.取大小())))
// 输出结果：
// ANSI小写带分割的十六进制字节集大小：14字节
// ANSI小写带分割的十六进制文本内容：48 65 6c 6c 6f
// 炫语言：验证ANSI十六进制字节集的原始内容
调试输出("ANSI十六进制字节集原始内容：")
调试输出十六进制((常量字符型A*)十六进制数据.取地址(), 十六进制数据.取大小())
// 输出结果：
// ANSI十六进制字节集原始内容：
// 34 38 36 35 36 43 36 43 36 46
// 字节解析：ANSI编码的"48656C6C6F"，每个字符占1字节

复制代码

--
58.到十六进制文本

// 示例：将字节集数据转换为十六进制文本
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：5字节
// 原始十六进制内容：
// 48 65 6C 6C 6F
// 炫语言：转换为十六进制文本（大写，不分割）
文本型十六进制文本 = 原数据集.到十六进制文本(真, 假)
调试输出("十六进制文本（大写，不分割）：" + 十六进制文本)
// 输出结果：
// 十六进制文本（大写，不分割）：48656C6C6F
// 炫语言：转换为十六进制文本（大写，分割）
文本型十六进制文本2 = 原数据集.到十六进制文本(真, 真)
调试输出("十六进制文本（大写，分割）：" + 十六进制文本2)
// 输出结果：
// 十六进制文本（大写，分割）：48 65 6C 6C 6F
// 炫语言：转换为十六进制文本（小写，分割）
文本型十六进制文本3 = 原数据集.到十六进制文本(假, 真)
调试输出("十六进制文本（小写，分割）：" + 十六进制文本3)
// 输出结果：
// 十六进制文本（小写，分割）：48 65 6c 6c 6f
// 炫语言：指定位置和长度转换
文本型部分十六进制文本 = 原数据集.到十六进制文本(真, 真, 1, 3)
调试输出("位置1开始，长度3字节的十六进制文本：" + 部分十六进制文本)
// 输出结果：
// 位置1开始，长度3字节的十六进制文本：65 6C 6C

复制代码

--
59.到十六进制文本A

// 示例：将字节集数据转换为ANSI十六进制文本
// 炫语言：定义字节集并添加数据
字节集原数据集
原数据集.添加文本A(A"Hello", 假)
// 炫语言：输出原始数据状态
调试输出("原始字节集大小：" + 到文本(原数据集.取大小()) + "字节")
调试输出("原始十六进制内容：")
调试输出十六进制((常量字符型A*)原数据集.取地址(), 原数据集.取大小())
// 输出结果：
// 原始字节集大小：5字节
// 原始十六进制内容：
// 48 65 6C 6C 6F
// 炫语言：转换为ANSI十六进制文本（大写，不分割）
文本型A 十六进制文本A = 原数据集.到十六进制文本A(真, 假)
调试输出("ANSI十六进制文本（大写，不分割）：" + A2W(十六进制文本A))
// 输出结果：
// ANSI十六进制文本（大写，不分割）：48656C6C6F
// 炫语言：转换为ANSI十六进制文本（大写，分割）
文本型A 十六进制文本A2 = 原数据集.到十六进制文本A(真, 真)
调试输出("ANSI十六进制文本（大写，分割）：" + A2W(十六进制文本A2))
// 输出结果：
// ANSI十六进制文本（大写，分割）：48 65 6C 6C 6F
// 炫语言：转换为ANSI十六进制文本（小写，分割）
文本型A 十六进制文本A3 = 原数据集.到十六进制文本A(假, 真)
调试输出("ANSI十六进制文本（小写，分割）：" + A2W(十六进制文本A3))
// 输出结果：
// ANSI十六进制文本（小写，分割）：48 65 6c 6c 6f
// 炫语言：指定位置和长度转换
文本型A 部分十六进制文本A = 原数据集.到十六进制文本A(真, 真, 1, 3)
调试输出("位置1开始，长度3字节的ANSI十六进制文本：" + A2W(部分十六进制文本A))
// 输出结果：
// 位置1开始，长度3字节的ANSI十六进制文本：65 6C 6C

复制代码

--
60.查找字节集

// 示例：在字节集中查找指定字节集
// 炫语言：定义主字节集并添加数据
字节集主数据集
主数据集.添加文本A(A"Hello World", 假)
// 炫语言：定义要查找的字节集
字节集查找集
查找集.添加文本A(A"World", 假)
// 炫语言：输出原始数据状态
调试输出("主字节集大小：" + 到文本(主数据集.取大小()) + "字节")
调试输出("主字节集内容：" + A2W(主数据集.取文本A(0, 主数据集.取大小())))
调试输出("查找字节集大小：" + 到文本(查找集.取大小()) + "字节")
调试输出("查找字节集内容：" + A2W(查找集.取文本A(0, 查找集.取大小())))
// 输出结果：
// 主字节集大小：11字节
// 主字节集内容：Hello World
// 查找字节集大小：5字节
// 查找字节集内容：World
// 炫语言：从位置0开始查找"World"
整型位置 = 主数据集.查找字节集(查找集, 0)
调试输出("查找'World'的位置：" + 到文本(位置))
// 输出结果：
// 查找'World'的位置：6
// 炫语言：从位置7开始查找（应该找不到）
位置 = 主数据集.查找字节集(查找集, 7)
调试输出("从位置7开始查找'World'的位置：" + 到文本(位置))
// 输出结果：
// 从位置7开始查找'World'的位置：-1
// 炫语言：查找不存在的字节集
字节集不存在集
不存在集.添加文本A(A"ABC", 假)
位置 = 主数据集.查找字节集(不存在集, 0)
调试输出("查找'ABC'的位置：" + 到文本(位置))
// 输出结果：
// 查找'ABC'的位置：-1
// 炫语言：查找单个字符
字节集字符集
字符集.添加字节型(0x6C) // 'l'
位置 = 主数据集.查找字节集(字符集, 0)
调试输出("查找字符'l'的位置：" + 到文本(位置))
// 输出结果：
// 查找字符'l'的位置：2

复制代码

		自动登录	找回密码
密码			立即注册

[模块] 基础模块-字节集示例51-60