基础模块-字节集示例41-50

qq1073176068

41.取正短整型
// 示例：从字节集获取正短整型数据
// 炫语言：定义字节集并存储正短整型数据
字节集 数据集
数据集.添加正短整型(65535)  // 最大无符号短整型值


// 炫语言：从位置0获取正短整型数据
正短整型 结果值 = 数据集.取正短整型(0)
调试输出("位置0的正短整型值：" + 到文本(结果值))


// 输出结果：
// 位置0的正短整型值：65535


// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 字节集大小：2字节
// 十六进制内容：FF FF
// 字节解析：FF FF=65535（小端存储）


// 炫语言：存储多个正短整型并分别获取
字节集 多数据集
多数据集.添加正短整型连续({1000, 2000, 3000})


// 炫语言：分别获取不同位置的正短整型值
正短整型 值1 = 多数据集.取正短整型(0)
正短整型 值2 = 多数据集.取正短整型(2)
正短整型 值3 = 多数据集.取正短整型(4)


调试输出("位置0的正短整型：" + 到文本(值1))
调试输出("位置2的正短整型：" + 到文本(值2))
调试输出("位置4的正短整型：" + 到文本(值3))


// 输出结果：
// 位置0的正短整型：1000
// 位置2的正短整型：2000
// 位置4的正短整型：3000
--
42.取浮点型
// 示例：从字节集获取浮点型数据
// 炫语言：定义字节集并存储浮点型数据
字节集 数据集
数据集.添加浮点型(3.14)


// 炫语言：从位置0获取浮点型数据
浮点型 结果值 = 数据集.取浮点型(0)
调试输出("位置0的浮点型值：" + 到文本(结果值))


// 输出结果：
// 位置0的浮点型值：3.1400001


// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 字节集大小：4字节
// 十六进制内容：C3 F5 48 40
// 字节解析：C3 F5 48 40=3.14（IEEE 754单精度，小端存储）


// 炫语言：存储多个浮点型并分别获取
字节集 多数据集
多数据集.添加浮点型连续({1.5, 2.5, 3.5})


// 炫语言：分别获取不同位置的浮点型值
浮点型 值1 = 多数据集.取浮点型(0)
浮点型 值2 = 多数据集.取浮点型(4)
浮点型 值3 = 多数据集.取浮点型(8)


调试输出("位置0的浮点型：" + 到文本(值1))
调试输出("位置4的浮点型：" + 到文本(值2))
调试输出("位置8的浮点型：" + 到文本(值3))


// 输出结果：
// 位置0的浮点型：1.5
// 位置4的浮点型：2.5
// 位置8的浮点型：3.5
--
43.取双浮点型
// 示例：从字节集获取双浮点型数据
// 炫语言：定义字节集并存储双浮点型数据
字节集 数据集
数据集.添加双浮点型(3.141592653589793)


// 炫语言：从位置0获取双浮点型数据
双浮点型 结果值 = 数据集.取双浮点型(0)
调试输出("位置0的双浮点型值：" + 到文本(结果值))


// 输出结果：
// 位置0的双浮点型值：3.14159265358979


// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 字节集大小：8字节
// 十六进制内容：18 2D 44 54 FB 21 09 40
// 字节解析：18 2D 44 54 FB 21 09 40=3.141592653589793（IEEE 754双精度，小端存储）


// 炫语言：存储多个双浮点型并分别获取
字节集 多数据集
多数据集.添加双浮点型连续({1.23456789, 2.34567890, 3.45678901})


// 炫语言：分别获取不同位置的双浮点型值
双浮点型 值1 = 多数据集.取双浮点型(0)
双浮点型 值2 = 多数据集.取双浮点型(8)
双浮点型 值3 = 多数据集.取双浮点型(16)


调试输出("位置0的双浮点型：" + 到文本(值1))
调试输出("位置8的双浮点型：" + 到文本(值2))
调试输出("位置16的双浮点型：" + 到文本(值3))


// 输出结果：
// 位置0的双浮点型：1.23456789
// 位置8的双浮点型：2.3456789
// 位置16的双浮点型：3.45678901
--
44.取字符型
// 示例：从字节集获取字符型数据
// 炫语言：定义字节集并存储字符型数据
字节集 数据集
数据集.添加字符型('A')


// 炫语言：从位置0获取字符型数据
字符型 结果值 = 数据集.取字符型(0)
调试输出("位置0的字符型值：" + 到文本(结果值))


// 输出结果：
// 位置0的字符型值：A


// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 字节集大小：2字节
// 十六进制内容：41 00
// 字节解析：41 00='A'（Unicode小端存储）


// 炫语言：存储多个字符型并分别获取
字节集 多数据集
多数据集.添加字符连续({'H', 'e', 'l', 'l', 'o'})


// 炫语言：分别获取不同位置的字符型值
字符型 值1 = 多数据集.取字符型(0)
字符型 值2 = 多数据集.取字符型(2)
字符型 值3 = 多数据集.取字符型(4)


调试输出("位置0的字符型：" + 到文本(值1))
调试输出("位置2的字符型：" + 到文本(值2))
调试输出("位置4的字符型：" + 到文本(值3))


// 输出结果：
// 位置0的字符型：H
// 位置2的字符型：e
// 位置4的字符型：l
--
45.取字节型
// 示例：从字节集获取字节型数据
// 炫语言：定义字节集并存储字节型数据
字节集 数据集
数据集.添加字节型(0xAB)


// 炫语言：从位置0获取字节型数据
字节型 结果值 = 数据集.取字节型(0)
文本型 十六进制文本 = 数据到十六进制文本(&结果值, 1, 真, 假)
调试输出("位置0的字节型值：" + 到文本(结果值) + " (十六进制: " + 十六进制文本 + ")")


// 输出结果：
// 位置0的字节型值：171 (十六进制: AB)


// 炫语言：验证字节集内容
调试输出("字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 字节集大小：1字节
// 十六进制内容：AB
// 字节解析：AB=171（十六进制）


// 炫语言：存储多个字节型并分别获取
字节集 多数据集
多数据集.添加字节型连续({0x12, 0x34, 0x56, 0x78, 0x9A})


// 炫语言：分别获取不同位置的字节型值
字节型 值1 = 多数据集.取字节型(0)
字节型 值2 = 多数据集.取字节型(1)
字节型 值3 = 多数据集.取字节型(2)
字节型 值4 = 多数据集.取字节型(3)
字节型 值5 = 多数据集.取字节型(4)


调试输出("位置0的字节型：" + 数据到十六进制文本(&值1, 1, 真, 假))
调试输出("位置1的字节型：" + 数据到十六进制文本(&值2, 1, 真, 假))
调试输出("位置2的字节型：" + 数据到十六进制文本(&值3, 1, 真, 假))
调试输出("位置3的字节型：" + 数据到十六进制文本(&值4, 1, 真, 假))
调试输出("位置4的字节型：" + 数据到十六进制文本(&值5, 1, 真, 假))


// 输出结果：
// 位置0的字节型：12
// 位置1的字节型：34
// 位置2的字节型：56
// 位置3的字节型：78
// 位置4的字节型：9A
--
46.清空
// 示例：清空字节集数据
// 炫语言：定义字节集并添加数据
字节集 数据集
数据集.添加文本A(A"Hello World", 假)


// 炫语言：输出清空前的状态
调试输出("清空前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("清空前十六进制内容：")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 清空前字节集大小：11字节
// 清空前十六进制内容：
// 48 65 6C 6C 6F 20 57 6F 72 6C 64


// 炫语言：清空字节集
数据集.清空()


// 炫语言：输出清空后的状态
调试输出("清空后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("清空后是否为空：" + 到文本(数据集.是否为空()))


// 输出结果：
// 清空后字节集大小：0字节
// 清空后是否为空：1
--
47.取大小
// 示例：获取字节集大小
// 炫语言：定义字节集并添加数据
字节集 数据集
数据集.添加文本A(A"Hello World", 假)


// 炫语言：获取字节集大小
整型 大小 = 数据集.取大小()
调试输出("字节集大小：" + 到文本(大小) + "字节")


// 输出结果：
// 字节集大小：11字节


// 炫语言：添加更多数据后再次获取大小
数据集.添加文本A(A" 你好", 假)
大小 = 数据集.取大小()
调试输出("添加数据后字节集大小：" + 到文本(大小) + "字节")


// 输出结果：
// 添加数据后字节集大小：16字节


// 炫语言：验证数据内容
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 十六进制内容：48 65 6C 6C 6F 20 57 6F 72 6C 64 20 C4 E3 BA C3
// 字节解析：48 65 6C 6C 6F 20 57 6F 72 6C 64="Hello World"、20=空格、C4 E3=你、BA C3=好
--
48.是否为空
// 示例：判断字节集是否为空
// 炫语言：定义空字节集
字节集 空数据集


// 炫语言：判断空字节集是否为空
逻辑型 是否为空 = 空数据集.是否为空()
调试输出("空字节集是否为空：" + 到文本(是否为空))


// 输出结果：
// 空字节集是否为空：1（真）


// 炫语言：定义非空字节集
字节集 非空数据集
非空数据集.添加文本A(A"Hello", 假)


// 炫语言：判断非空字节集是否为空
是否为空 = 非空数据集.是否为空()
调试输出("非空字节集是否为空：" + 到文本(是否为空))
调试输出("非空字节集大小：" + 到文本(非空数据集.取大小()) + "字节")


// 输出结果：
// 非空字节集是否为空：0（假）
// 非空字节集大小：5字节


// 炫语言：清空非空数据集后再次判断
非空数据集.清空()
是否为空 = 非空数据集.是否为空()
调试输出("清空后字节集是否为空：" + 到文本(是否为空))


// 输出结果：
// 清空后字节集是否为空：1（真）
--
49.置数据
// 示例：重置字节集数据
// 炫语言：定义字节集并添加初始数据
字节集 数据集
数据集.添加文本A(A"Hello", 假)


// 炫语言：输出重置前的状态
调试输出("重置前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置前十六进制内容：")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 重置前字节集大小：5字节
// 重置前十六进制内容：48 65 6C 6C 6F


// 炫语言：准备新数据并重置字节集
文本型A 新数据 = A"World"
数据集.置数据(新数据.取地址(), 新数据.取大小())


// 炫语言：输出重置后的状态
调试输出("重置后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置后十六进制内容：")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 重置后字节集大小：5字节
// 重置后十六进制内容：57 6F 72 6C 64


// 炫语言：使用字节数组重置数据
字节型 字节数组[] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC}
数据集.置数据(字节数组, 6)


// 炫语言：输出再次重置后的状态
调试输出("再次重置后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("再次重置后十六进制内容：")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 再次重置后字节集大小：6字节
// 再次重置后十六进制内容：12 34 56 78 9A BC
--
50.置文本
// 示例：重置字节集为Unicode文本
// 炫语言：定义字节集并添加初始数据
字节集 数据集
数据集.添加文本A(A"Hello", 假)


// 炫语言：输出重置前的状态
调试输出("重置前字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置前十六进制内容：")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 重置前字节集大小：5字节
// 重置前十六进制内容：48 65 6C 6C 6F


// 炫语言：重置为Unicode文本"你好炫语言"
数据集.置文本("你好炫语言")


// 炫语言：输出重置后的状态
调试输出("重置后字节集大小：" + 到文本(数据集.取大小()) + "字节")
调试输出("重置后文本内容：" + 数据集.取文本(0, 5))
调试输出("重置后十六进制内容：")
调试输出十六进制((常量 字符型A*)数据集.取地址(), 数据集.取大小())


// 输出结果：
// 重置后字节集大小：10字节
// 重置后文本内容：你好炫语言
// 重置后十六进制内容：60 4F 7D 59 AB 70 8B ED 00 8A
// 字节解析：60 4F='你'、7D 59='好'、AB 70='炫'、8B ED='语'、00 8A='言'（Unicode小端存储）