基础模块-文本型A示例1-21

qq1073176068 · 发表于 2025-9-28 14:29:45

本帖最后由 qq1073176068 于 2025-9-30 08:10 编辑

1.取地址

// 示例：获取文本型A数据的内存地址
// 炫语言：定义文本型A变量（多字节编码，中文“炫语言”+英文“Test123”）
文本型A 文本A数据 = A"炫语言Test123"
// 炫语言：获取文本型A的内存地址（返回常量字符型A*，直接关联文本首字符）
常量字符型A* 文本A地址 = 文本A数据.取地址()
// 炫语言：输出文本内容、字节数及地址关联的文本信息
调试输出("文本型A内容：" + A2W(文本A数据))
调试输出("文本型A字节数：" + 到文本(文本A数据.取大小()))
调试输出("文本型A内存地址（首字符指针）：" + A2W(文本A地址))
// 输出结果：
// 文本型A内容：炫语言Test123
// 文本型A字节数：13（“炫语言”6字节+“Test123”7字节）
// 文本型A内存地址（首字符指针）：炫语言Test123

复制代码

--
2.取大小

// 示例：获取文本型A数据的字节长度
// 炫语言：定义英文文本型A变量（1字节/字符）
文本型A 英文文本A = A"Hello World"
// 炫语言：获取英文文本的字节数
正整型英文字节数 = 英文文本A.取大小()
// 炫语言：定义中文文本型A变量（2字节/字符，GBK编码）
文本型A 中文文本A = A"你好炫语言"
// 炫语言：获取中文文本的字节数
正整型中文字节数 = 中文文本A.取大小()
// 输出结果
调试输出("英文文本A内容：" + A2W(英文文本A))
调试输出("英文文本A字节数：" + 到文本(英文字节数))
调试输出("中文文本A内容：" + A2W(中文文本A))
调试输出("中文文本A字节数：" + 到文本(中文字节数))
// 输出结果：
// 英文文本A内容：Hello World
// 英文文本A字节数：11
// 中文文本A内容：你好炫语言
// 中文文本A字节数：10（5个中文×2字节）

复制代码

--
3.置大小

// 示例：设置文本型A的内存大小（截断或填充）
// 炫语言：定义初始文本型A变量
文本型A 文本A数据 = A"Hello World"
// 炫语言：输出置大小前状态
调试输出("置大小前内容：" + A2W(文本A数据))
调试输出("置大小前字节数：" + 到文本(文本A数据.取大小()))
// 炫语言：置大小为5字节（截断超出部分）
文本A数据.置大小(5)
调试输出("置大小(5)后内容：" + A2W(文本A数据))
调试输出("置大小(5)后字节数：" + 到文本(文本A数据.取大小()))
// 炫语言：置大小为10字节，用字符'A'填充（多字节编码下1字节/填充字符）
文本A数据.置大小(10, 'A')
调试输出("置大小(10,'A')后内容：" + A2W(文本A数据))
调试输出("置大小(10,'A')后字节数：" + 到文本(文本A数据.取大小()))
// 输出结果：
// 置大小前内容：Hello World
// 置大小前字节数：11
// 置大小(5)后内容：Hello
// 置大小(5)后字节数：5
// 置大小(10,'A')后内容：HelloAAAAA
// 置大小(10,'A')后字节数：10

复制代码

--
4.预置大小

// 示例：文本型A简单预置大小操作（匹配指定字节数）
// 1. 定义初始文本型A变量（“初始内容”4中文，GBK编码占8字节）
文本型A 文本A数据 = A"初始内容"
// 2. 输出预置前状态
调试输出("预置前内容：" + A2W(文本A数据))
调试输出("预置前字节数：" + 到文本(文本A数据.取大小()))
// 3. 预置30字节内存（提前留空间，不改变当前内容和字节数）
文本A数据.预置大小(30)
// 4. 输出预置后状态
调试输出("预置30字节后内容：" + A2W(文本A数据))
调试输出("预置30字节后字节数：" + 到文本(文本A数据.取大小()))
// 5. 拼接9字节补充内容（“_Test1234”：1字节“_”+8字节英文，共9字节）
文本A数据 = 文本A数据 + A"_Test1234"
// 6. 输出最终结果（8+9=17字节）
调试输出("拼接后内容：" + A2W(文本A数据))
调试输出("拼接后字节数：" + 到文本(文本A数据.取大小()))
// 输出结果：
// 预置前内容：初始内容
// 预置前字节数：8
// 预置30字节后内容：初始内容
// 预置30字节后字节数：8
// 拼接后内容：初始内容_Test1234
// 拼接后字节数：17

复制代码

--
5.是否为空

// 示例：判断文本型A是否为空
文本型A 空文本A = A"" // 空文本
文本型A 非空文本A = A"测试" // 非空文本（2中文，4字节）
// 调用是否为空方法，返回1（真）/0（假）
调试输出("空文本A是否为空：" + 到文本(空文本A.是否为空()))
调试输出("非空文本A是否为空：" + 到文本(非空文本A.是否为空()))
// 输出结果：
// 空文本A是否为空：1
// 非空文本A是否为空：0

复制代码

--
6.添加

// 示例：给文本型A添加内容
文本型A 源文本A = A"Hello" // 初始文本（5字节）
文本型A 待加文本A = A"123" // 待添加文本（3字节）
// 调用添加方法，拼接内容
源文本A.添加(待加文本A)
// 输出结果
调试输出("添加后内容：" + A2W(源文本A))
调试输出("添加后字节数：" + 到文本(源文本A.取大小()))
// 输出结果：
// 添加后内容：Hello123
// 添加后字节数：8

复制代码

--
7.添加2

// 示例：添加单个字符到文本型A，确保结果为“num:A”且字节数5
文本型A 源文本A = A"num:" // 初始文本（"num:"共4字节：n/u/m/:各1字节）
文本型A 单字符文本A = A"A" // 存储待添加的单个字符'A'（1字节）
// 定义常量指针，匹配取地址()返回类型，避免限定符错误
常量字符型A* 字符指针 = 单字符文本A.取地址()
// 调用添加2：添加1次'A'（新增1字节，4+1=5字节）
源文本A.添加2(字符指针, 1)
// 输出结果（完全匹配要求）
调试输出("添加后内容：" + A2W(源文本A))
调试输出("添加后字节数：" + 到文本(源文本A.取大小()))
// 输出结果：
// 添加后内容：num:A
// 添加后字节数：5

复制代码

--
8.插入

// 示例：在文本型A指定位置插入内容
文本型A 源文本A = A"AB" // 初始文本（2字节）
文本型A 插入文本A = A"12" // 待插入文本（2字节）
// 在位置1插入（原“AB”→“A12B”）
源文本A.插入(1, 插入文本A)
// 输出结果
调试输出("插入后内容：" + A2W(源文本A))
调试输出("插入后字节数：" + 到文本(源文本A.取大小()))
// 输出结果：
// 插入后内容：A12B
// 插入后字节数：4

复制代码

--
9.替换

// 示例：替换文本型A数据中指定范围的内容
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World
// 原始文本长度：11字节
// 炫语言：替换位置6到10的内容为"炫语言"（实际替换位置6-10，共5个字符）
文本变量.替换(6, 10, A"炫语言")
调试输出("替换后文本内容：" + A2W(文本变量))
调试输出("替换后文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 替换后文本内容：Hello 炫语言d
// 替换后文本长度：13字节
// 炫语言：替换位置0到4的内容为"你好"（实际替换位置0-4，共5个字符）
文本变量.替换(0, 4, A"你好")
调试输出("再次替换后文本内容：" + A2W(文本变量))
调试输出("再次替换后文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 再次替换后文本内容：你好o 炫语言d
// 再次替换后文本长度：13字节

复制代码

--
10.替换子文本

// 示例：替换文本型A数据中的子字符串
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, Hello 炫语言"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, Hello 炫语言
// 原始文本长度：25字节
// 炫语言：将所有的"Hello"替换为"Hi"
文本变量.替换子文本(A"Hello", A"Hi")
调试输出("替换子文本后内容：" + A2W(文本变量))
调试输出("替换后文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 替换子文本后内容：Hi World, Hi 炫语言
// 替换后文本长度：19字节
// 炫语言：将"炫语言"替换为"XuanYuYan"
文本变量.替换子文本(A"炫语言", A"XuanYuYan")
调试输出("再次替换后内容：" + A2W(文本变量))
调试输出("再次替换后文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 再次替换后内容：Hi World, Hi XuanYuYan
// 再次替换后文本长度：22字节

复制代码

--
11.替换指定数量

// 示例：替换文本型A数据中指定位置和数量的内容
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, Hello 炫语言"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, Hello 炫语言
// 原始文本长度：25字节
// 炫语言：从位置0开始替换5个字符为"Hi"
文本变量.替换指定数量(0, 5, A"Hi")
调试输出("替换指定数量后内容：" + A2W(文本变量))
调试输出("替换后文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 替换指定数量后内容：Hi World, Hello 炫语言
// 替换后文本长度：22字节
// 炫语言：从位置18开始替换2个字符为"ABC"
文本变量.替换指定数量(18, 2, A"ABC")
调试输出("再次替换后内容：" + A2W(文本变量))
调试输出("再次替换后文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 再次替换后内容：Hi World, Hello 炫ABC言
// 再次替换后文本长度：23字节

复制代码

--
12.查找

// 示例：在文本型A数据中查找子字符串
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, Hello 炫语言"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, Hello 炫语言
// 原始文本长度：25字节
// 炫语言：查找"World"子字符串
整型位置1 = 文本变量.查找(A"World")
调试输出("查找'World'的位置：" + 到文本(位置1))
// 输出结果：
// 查找'World'的位置：6
// 炫语言：查找"炫语言"子字符串
整型位置2 = 文本变量.查找(A"炫语言")
调试输出("查找'炫语言'的位置：" + 到文本(位置2))
// 输出结果：
// 查找'炫语言'的位置：19
// 炫语言：查找不存在的子字符串
整型位置3 = 文本变量.查找(A"ABC")
调试输出("查找'ABC'的位置：" + 到文本(位置3))
// 输出结果：
// 查找'ABC'的位置：-1

复制代码

--
13.查找2

// 示例：从指定位置开始在文本型A数据中查找子字符串
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, Hello 炫语言"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, Hello 炫语言
// 原始文本长度：25字节
// 炫语言：从位置0开始查找"Hello"
整型位置1 = 文本变量.查找2(A"Hello", 0)
调试输出("从位置0查找'Hello'的位置：" + 到文本(位置1))
// 输出结果：
// 从位置0查找'Hello'的位置：0
// 炫语言：从位置1开始查找"Hello"（跳过第一个Hello）
整型位置2 = 文本变量.查找2(A"Hello", 1)
调试输出("从位置1查找'Hello'的位置：" + 到文本(位置2))
// 输出结果：
// 从位置1查找'Hello'的位置：13
// 炫语言：从位置14开始查找"Hello"（应该找不到）
整型位置3 = 文本变量.查找2(A"Hello", 14)
调试输出("从位置14查找'Hello'的位置：" + 到文本(位置3))
// 输出结果：
// 从位置14查找'Hello'的位置：-1
// 炫语言：从位置19开始查找"炫语言"
整型位置4 = 文本变量.查找2(A"炫语言", 19)
调试输出("从位置19查找'炫语言'的位置：" + 到文本(位置4))
// 输出结果：
// 从位置19查找'炫语言'的位置：19

复制代码

--
14.反向查找

// 示例：在文本型A数据中反向查找子字符串
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, Hello 炫语言, Hello"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, Hello 炫语言, Hello
// 原始文本长度：32字节
// 炫语言：反向查找"Hello"子字符串
整型位置1 = 文本变量.反向查找(A"Hello")
调试输出("反向查找'Hello'的位置：" + 到文本(位置1))
// 输出结果：
// 反向查找'Hello'的位置：27
// 炫语言：反向查找"炫语言"子字符串
整型位置2 = 文本变量.反向查找(A"炫语言")
调试输出("反向查找'炫语言'的位置：" + 到文本(位置2))
// 输出结果：
// 反向查找'炫语言'的位置：19
// 炫语言：反向查找不存在的子字符串
整型位置3 = 文本变量.反向查找(A"ABC")
调试输出("反向查找'ABC'的位置：" + 到文本(位置3))
// 输出结果：
// 反向查找'ABC'的位置：-1

复制代码

--
15.反向查找2

// 示例：从指定位置开始在文本型A数据中反向查找子字符串
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, Hello 炫语言, Hello"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, Hello 炫语言, Hello
// 原始文本长度：32字节
// 炫语言：从末尾开始反向查找"Hello"（默认开始位置-1）
整型位置1 = 文本变量.反向查找2(A"Hello")
调试输出("从末尾反向查找'Hello'的位置：" + 到文本(位置1))
// 输出结果：
// 从末尾反向查找'Hello'的位置：27
// 炫语言：从位置20开始反向查找"Hello"
整型位置2 = 文本变量.反向查找2(A"Hello", 20)
调试输出("从位置20反向查找'Hello'的位置：" + 到文本(位置2))
// 输出结果：
// 从位置20反向查找'Hello'的位置：13
// 炫语言：从位置10开始反向查找"Hello"
整型位置3 = 文本变量.反向查找2(A"Hello", 10)
调试输出("从位置10反向查找'Hello'的位置：" + 到文本(位置3))
// 输出结果：
// 从位置10反向查找'Hello'的位置：0
// 炫语言：从位置5开始反向查找"炫语言"
整型位置4 = 文本变量.反向查找2(A"炫语言", 5)
调试输出("从位置5反向查找'炫语言'的位置：" + 到文本(位置4))
// 输出结果：
// 从位置5反向查找'炫语言'的位置：-1

复制代码

--
16.取子文本

// 示例：从文本型A数据中提取指定范围的子字符串
// 炫语言：定义文本型A变量
文本型A 文本变量 = A"Hello World, 你好炫语言"
// 炫语言：输出原始文本状态
调试输出("原始文本内容：" + A2W(文本变量))
调试输出("原始文本长度：" + 到文本(文本变量.取大小()) + "字节")
// 输出结果：
// 原始文本内容：Hello World, 你好炫语言
// 原始文本长度：23字节
// 炫语言：提取位置0开始的5个字符（"Hello"）
文本型A 子文本1 = 文本变量.取子文本(0, 5)
调试输出("位置0开始取5个字符：" + A2W(子文本1))
调试输出("子文本1长度：" + 到文本(子文本1.取大小()) + "字节")
// 输出结果：
// 位置0开始取5个字符：Hello
// 子文本1长度：5字节
// 炫语言：提取位置6开始的5个字符（"World"）
文本型A 子文本2 = 文本变量.取子文本(6, 5)
调试输出("位置6开始取5个字符：" + A2W(子文本2))
调试输出("子文本2长度：" + 到文本(子文本2.取大小()) + "字节")
// 输出结果：
// 位置6开始取5个字符：World
// 子文本2长度：5字节
// 炫语言：提取位置13开始的5个字符（"你好炫语言"中的部分字符）
文本型A 子文本3 = 文本变量.取子文本(13, 5)
调试输出("位置13开始取5个字符：" + A2W(子文本3))
调试输出("子文本3长度：" + 到文本(子文本3.取大小()) + "字节")
// 输出结果：
// 位置13开始取5个字符：你好?
// 子文本3长度：5字节
// 炫语言：提取位置18开始的0个字符（空文本）
文本型A 子文本4 = 文本变量.取子文本(18, 0)
调试输出("位置18开始取0个字符：" + A2W(子文本4))
调试输出("子文本4是否为空：" + 到文本(子文本4.是否为空()))
// 输出结果：
// 位置18开始取0个字符：
// 子文本4是否为空：1

复制代码

--
17.取尾字符

// 文本型A::取尾字符() 中文场景修正版（解决末尾字符显示“?”的乱码问题）
// 核心：中文文本型A的“尾字符”是2字节GBK编码，需按多字节读取，避免单字节截取乱码
// 1. 定义中文多字节文本（ANSI-GBK编码，"你好炫语言"共5个中文=10字节，每个中文占2字节）
文本型A 中文文本A = A"你好炫语言"
// 2. 手动实现“取中文尾字符”（适配中文多字节特性，避免单字节读取乱码）
// 步骤1：获取文本型A总字节数（10字节）
正整型总字节数 = 中文文本A.取大小()
// 步骤2：计算中文尾字符的起始字节位置（总字节数-2，因中文1字符=2字节）
正整型尾字符起始位置 = 总字节数 - 2
// 步骤3：用“取子文本”提取末尾2字节（即最后1个中文字符）
文本型A 中文尾字符文本A = 中文文本A.取子文本(尾字符起始位置, 2)
// 3. 调试输出（完全适配GBK编码，无乱码）
调试输出("文本型A内容：" + A2W(中文文本A)) // A2W正确转换GBK到Unicode
调试输出("文本型A总字节数：" + 到文本(总字节数) + "字节（5中文×2字节）")
调试输出("文本型A末尾字符：" + A2W(中文尾字符文本A)) // 输出正确中文尾字符
// 预期输出：
// 文本型A内容：你好炫语言
// 文本型A总字节数：10字节（5中文×2字节）
// 文本型A末尾字符：言

复制代码

--
18.取首字符

// 文本型A::取首字符() 中文适配版（解决多字节编码首字符乱码，严格兼容编译规则）
// 核心：中文文本型A首字符为2字节GBK编码，需按多字节提取，避免单字节读取错误
// 1. 定义中英文混合文本型A（ANSI-GBK编码："炫语言Test"，中文3字符=6字节，英文4字符=4字节，总计10字节）
文本型A 混合文本A = A"炫语言Test"
// 2. 实现文本型A取首字符（适配中文多字节特性，确保提取完整首字符）
// 步骤1：获取文本型A总字节数（验证编码长度）
正整型总字节数 = 混合文本A.取大小()
// 步骤2：判断首字符类型（中文2字节/英文1字节，此处以中文首字符为例，通用适配）
// 中文首字符起始位置0，提取2字节；若为英文则提取1字节，可根据实际场景调整
正整型首字符字节数 = 2 // "炫"为中文，占2字节
文本型A 首字符文本A = 混合文本A.取子文本(0, 首字符字节数) // 从位置0提取2字节，即首字符“炫”
// 3. 调试输出（无编码乱码，完全匹配A2W与调试输出参数规则）
调试输出("文本型A内容：" + A2W(混合文本A)) // A2W正确转换GBK到Unicode，无乱码
调试输出("文本型A总字节数：" + 到文本(总字节数) + "字节（3中文×2 + 4英文×1）")
调试输出("文本型A首字符：" + A2W(首字符文本A)) // 输出正确中文首字符
// 预期输出：
// 文本型A内容：炫语言Test
// 文本型A总字节数：10字节（3中文×2 + 4英文×1）
// 文本型A首字符：炫

复制代码

--
19.交换

// 示例：交换两个文本型A对象的内容
// 炫语言：定义两个待交换的文本型A变量（多字节编码，GBK格式）
// 中文文本："你好编程"共4个字符，每个中文占2字节，总计8字节
文本型A 文本A_中文 = A"你好编程"
// 英文文本："Hello Code"共10个字符，每个英文占1字节，总计10字节
文本型A 文本A_英文 = A"Hello Code"
// 炫语言：输出交换前的文本状态（内容+字节数）
调试输出("交换前：文本A_中文 = " + A2W(文本A_中文) + "，字节数 = " + 到文本(文本A_中文.取大小()))
调试输出("交换前：文本A_英文 = " + A2W(文本A_英文) + "，字节数 = " + 到文本(文本A_英文.取大小()))
// 输出结果：
// 交换前：文本A_中文 = 你好编程，字节数 = 8
// 交换前：文本A_英文 = Hello Code，字节数 = 10
// 炫语言：调用交换()方法（空类型返回，参数为文本型A&），交换两个文本型A的内容
文本A_中文.交换(文本A_英文)
// 炫语言：输出交换后的文本状态（验证内容与字节数互换结果）
调试输出("交换后：文本A_中文 = " + A2W(文本A_中文) + "，字节数 = " + 到文本(文本A_中文.取大小()))
调试输出("交换后：文本A_英文 = " + A2W(文本A_英文) + "，字节数 = " + 到文本(文本A_英文.取大小()))
// 输出结果：
// 交换后：文本A_中文 = Hello Code，字节数 = 10
// 交换后：文本A_英文 = 你好编程，字节数 = 8

复制代码

--
20.删除

// 示例：文本型A::删除() 正确适配（以字节为单位计算位置/长度，解决中文乱码）
// 核心：文本型A为多字节编码（GBK），中文1字符=2字节、英文1字符=1字节，删除需按字节计算参数
// 炫语言：定义文本型A变量（GBK编码："炫语言Test123"=3中文×2字节 + 6英文×1字节=12字节，实际存储含终止符可能为13字节，以实际取大小为准）
文本型A 原文本A = A"炫语言Test123"
正整型原字节数 = 原文本A.取大小() // 获取实际字节数，避免硬编码偏差
// 示例1：删除位置2（字节单位）的2个字节（即1个中文字符“言”）
// 说明：“炫”(0-1字节)、“语”(2-3字节)、“言”(4-5字节)，删除“言”需传开始位置4、长度2
文本型A 文本A_示例1 = 原文本A
// 关键修正：按字节计算开始位置（4）和长度（2），匹配中文2字节特性
文本A_示例1.删除(4, 2)
// 输出示例1结果
调试输出("示例1-原文本A：" + A2W(原文本A) + "，实际字节数：" + 到文本(原字节数))
调试输出("示例1-删除字节4-5（“言”）后：" + A2W(文本A_示例1) + "，字节数：" + 到文本(文本A_示例1.取大小()))
// 输出结果：
// 示例1-原文本A：炫语言Test123，实际字节数：13
// 示例1-删除字节4-5（“言”）后：炫语Test123，字节数：11（减少2字节，无乱码）
// 示例2：删除位置6（字节单位）的3个字节（即“Tes”3个英文字符）
// 说明：文本字节分布：“炫”(0-1)、“语”(2-3)、“言”(4-5)、“T”(6)、“e”(7)、“s”(8)、“t”(9)...，删除“Tes”需传开始位置6、长度3
文本型A 文本A_示例2 = 原文本A
// 关键修正：按字节计算开始位置（6）和长度（3），匹配英文1字节特性
文本A_示例2.删除(6, 3)
// 输出示例2结果
调试输出("\n示例2-原文本A：" + A2W(原文本A) + "，实际字节数：" + 到文本(原字节数))
调试输出("示例2-删除字节6-8（“Tes”）后：" + A2W(文本A_示例2) + "，字节数：" + 到文本(文本A_示例2.取大小()))
// 输出结果：
// 示例2-原文本A：炫语言Test123，实际字节数：13
// 示例2-删除字节6-8（“Tes”）后：炫语言t123，字节数：10（减少3字节，无乱码）

复制代码

--
21.取字符

// 示例：文本型A::取字符() 适配GBK编码（无循环无判断，直接计算）
// 核心：GBK中文1字符=2字节，明确字符分布后直接定位
文本型A 原文本A = A"炫语言Test" // 字符：0(炫)、1(语)、2(言)、3(T)、4(e)、5(s)、6(t)
正整型原字节数 = 原文本A.取大小() // 实际字节数10（无终止符场景）
// 需求：获取字符位置2的字符（中文“言”）
整型目标字符索引 = 2
// 直接计算起始字节：中文起始字节=字符索引×2（“言”对应起始字节4）
整型目标起始字节 = 目标字符索引 * 2
// 提取2字节完整中文（匹配GBK中文长度）
文本型A 目标字符结果 = 原文本A.取子文本(目标起始字节, 2)
// 输出
调试输出("原文本A：" + A2W(原文本A) + "，字节数：" + 到文本(原字节数))
调试输出("字符位置" + 到文本(目标字符索引) + "：" + A2W(目标字符结果))
// 输出结果：
// 原文本A：炫语言Test，字节数：10
// 字符位置2：言

复制代码

--

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

[模块] 基础模块-文本型A示例1-21