纯汇编版 数组快速叠加成字符串 没快文快 不过可以动态查看添加过程 快文反复取文本卡

cf2006a

  

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
a	文本型
g	文本型		1000000
t	整数型
i	整数型
字符长度	整数型
补位	文本型
补位地址	整数型
找到位置	整数型
写入位置	整数型
快文结果	文本型

计次循环首 (1000000, i)
g [i] ＝ 到文本 (取随机数 (1, 10000))
计次循环尾 ()
a ＝ 取空白文本 (1024 × 1024 × 10)
t ＝ 取启动时间 ()
快文结果 ＝ 数组叠加_快文 (g)
t ＝ 取启动时间 () － t
调试输出 (t)
t ＝ 取启动时间 ()
计次循环首 (1000000, i)
字符长度 ＝ _取文本长度_ASM_地址 (g [i])
_文本叠加_参数版_ASM (g [i], a, 写入位置)
写入位置 ＝ 写入位置 ＋ 字符长度
计次循环尾 ()
t ＝ 取启动时间 () － t
调试输出 (t)

子程序名	返回值类型	公开	备 注
数组叠加_快文	文本型		默认去空 不去重复 去重复用的是易节点
参数名	类 型	参考	可空	数组	备 注
数组文本	文本型

变量名	类 型	静态	数组	备 注
快速	快速文本对象
i	整数型
总长度	整数型
成员数	整数型

计次循环首 (成员数, i)
总长度 ＝ 总长度 ＋ 取文本长度 (数组文本 [i])
计次循环尾 ()
快速.置内存增量 (总长度)
计次循环首 (成员数, i)
快速.添加 (数组文本 [i])
计次循环尾 ()
返回 (快速.取文本 (, ))

子程序名	返回值类型	公开	备 注
_取文本长度_ASM_地址	整数型		取文本型数据的长度
参数名	类 型	参考	可空	数组	备 注
文本	文本型				参数值指定欲检查其长度的文本数据。

变量名	类 型	静态	数组	备 注
文本指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 141, 112, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 240, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
_文本叠加_参数版_ASM			纯汇编算法编写作者*F006a 单字节用空白填充
参数名	类 型	参考	可空	数组	备 注
要写的文本	文本型
缓冲文本	文本型				注意叠加后文本长度
写入位置	整数型

置入代码 ({ 139, 125, 8, 139, 69, 12, 139, 77, 16, 139, 63, 139, 0, 138, 31, 128, 251, 0, 116, 7, 136, 28, 8, 71, 65, 235, 242, 201, 194, 12, 0 })

i支持库列表	支持库注释
spec	特殊功能支持库
commobj	通用对象支持库

.版本 2<br /> .支持库 spec<br /> .支持库 commobj<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 a, 文本型<br /> .局部变量 g, 文本型, , "1000000"<br /> .局部变量 t, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 字符长度, 整数型<br /> .局部变量 补位, 文本型<br /> .局部变量 补位地址, 整数型<br /> .局部变量 找到位置, 整数型<br /> .局部变量 写入位置, 整数型<br /> .局部变量 快文结果, 文本型<br /> <br /> .计次循环首 (1000000, i)<br />     g <i> ＝ 到文本 (取随机数 (1, 10000))<br /> .计次循环尾 ()<br /> a ＝ 取空白文本 (1024 × 1024 × 10)<br /> t ＝ 取启动时间 ()<br /> 快文结果 ＝ 数组叠加_快文 (g)<br /> t ＝ 取启动时间 () － t<br /> 调试输出 (t)<br /> t ＝ 取启动时间 ()<br /> .计次循环首 (1000000, i)<br />     字符长度 ＝ _取文本长度_ASM_地址 (g <i>)<br />     _文本叠加_参数版_ASM (g <i>, a, 写入位置)<br />     写入位置 ＝ 写入位置 ＋ 字符长度<br /> .计次循环尾 ()<br /> t ＝ 取启动时间 () － t<br /> 调试输出 (t)<br /> <br /> <br /> .子程序 数组叠加_快文, 文本型, 公开, 默认去空 不去重复 去重复用的是易节点<br /> .参数 数组文本, 文本型, 数组<br /> .局部变量 快速, 快速文本对象<br /> .局部变量 i, 整数型<br /> .局部变量 总长度, 整数型<br /> .局部变量 成员数, 整数型<br /> <br /> .计次循环首 (成员数, i)<br />     总长度 ＝ 总长度 ＋ 取文本长度 (数组文本 <i>)<br /> .计次循环尾 ()<br /> 快速.置内存增量 (总长度)<br /> .计次循环首 (成员数, i)<br />     快速.添加 (数组文本 <i>)<br /> .计次循环尾 ()<br /> 返回 (快速.取文本 (, ))<br /> <br /> <br /> <br /> .子程序 _取文本长度_ASM_地址, 整数型, 公开, 取文本型数据的长度<br /> .参数 文本, 文本型, , 参数值指定欲检查其长度的文本数据。<br /> .局部变量 文本指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 141, 112, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 240, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 _文本叠加_参数版_ASM, , 公开, 纯汇编算法编写作者*F006a 单字节用空白填充<br /> .参数 要写的文本, 文本型<br /> .参数 缓冲文本, 文本型, , 注意叠加后文本长度<br /> .参数 写入位置, 整数型<br /> <br /> 置入代码 ({ 139, 125, 8, 139, 69, 12, 139, 77, 16, 139, 63, 139, 0, 138, 31, 128, 251, 0, 116, 7, 136, 28, 8, 71, 65, 235, 242, 201, 194, 12, 0 })

快文确实够快 不过不能动态查看 添加 过程如 添加后 我要查看一下有没有重复 就的 快文.取文本 那会很卡 ，而汇编这个版本直接 调试输出 填充的变量就可以了

各有优点吧 看功能 取决选哪个用吧！这个版本 超牛 100W叠加00.3秒 去重复也就0.04秒 非常感谢  1101672929 帮忙优化

  

子程序名	返回值类型	公开	备 注
数组叠加	文本型		比快速文本快一倍左右吧
参数名	类 型	参考	可空	数组	备 注
数组文本	文本型
过滤重复	逻辑型				真为过滤掉重复的文本

变量名	类 型	静态	数组	备 注
数组长度	整数型		0
i	整数型
返回文本	文本型
写入位置	整数型
总长度	整数型
数据地址	整数型
节点	节点
是否存在	逻辑型

重定义数组 (数组长度, 假, 取数组成员数 (数组文本))
计次循环首 (取数组成员数 (数组文本), i)
数组长度 [i] ＝ _取文本长度 (数组文本 [i])
总长度 ＝ 总长度 ＋ 数组长度 [i]
计次循环尾 ()
返回文本 ＝ 取空白文本 (总长度)
数据地址 ＝ 取变量数据地址 (返回文本)
如果 (过滤重复)
计次循环首 (取数组成员数 (数组文本), i)  ' 这里自己用哈希表判断是否重复了,个人推荐"E2EE支持库"里的"存取键值表",这里为了大家都能运行,直接使用节点
如果真 (节点.取逻辑值 (数组文本 [i], 是否存在) 且 是否存在)  ' 已经存在的,跳过
到循环尾 ()
节点.加入属性 (数组文本 [i], 真)
_文本叠加_参数版_ASM (数组文本 [i], 数据地址, 写入位置)
写入位置 ＝ 写入位置 ＋ 数组长度 [i]
计次循环尾 ()
写到内存 ({ 0 }, 数据地址 ＋ 写入位置, 1)  ' 写入文本终止符
计次循环首 (取数组成员数 (数组文本), i)  ' 不过滤重复的
_文本叠加_参数版_ASM (数组文本 [i], 数据地址, 写入位置)
写入位置 ＝ 写入位置 ＋ 数组长度 [i]
计次循环尾 ()
返回 (返回文本)

i支持库列表	支持库注释
EDataStructure	数据结构支持库
spec	特殊功能支持库

.版本 2<br /> .支持库 EDataStructure<br /> .支持库 spec<br /> <br /> .子程序 数组叠加, 文本型, , 比快速文本快一倍左右吧<br /> .参数 数组文本, 文本型, 数组<br /> .参数 过滤重复, 逻辑型, 可空, 真为过滤掉重复的文本<br /> .局部变量 数组长度, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 返回文本, 文本型<br /> .局部变量 写入位置, 整数型<br /> .局部变量 总长度, 整数型<br /> .局部变量 数据地址, 整数型<br /> .局部变量 节点, 节点<br /> .局部变量 是否存在, 逻辑型<br /> <br /> 重定义数组 (数组长度, 假, 取数组成员数 (数组文本))<br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     数组长度 <i> ＝ _取文本长度 (数组文本 <i>)<br />     总长度 ＝ 总长度 ＋ 数组长度 <i><br /> .计次循环尾 ()<br /> 返回文本 ＝ 取空白文本 (总长度)<br /> 数据地址 ＝ 取变量数据地址 (返回文本)<br /> .如果 (过滤重复)<br />     .计次循环首 (取数组成员数 (数组文本), i)  ' 这里自己用哈希表判断是否重复了,个人推荐"E2EE支持库"里的"存取键值表",这里为了大家都能运行,直接使用节点<br />         .如果真 (节点.取逻辑值 (数组文本 <i>, 是否存在) 且 是否存在)  ' 已经存在的,跳过<br />             到循环尾 ()<br />         .如果真结束<br />         节点.加入属性 (数组文本 <i>, 真)<br />         _文本叠加_参数版_ASM (数组文本 <i>, 数据地址, 写入位置)<br />         写入位置 ＝ 写入位置 ＋ 数组长度 <i><br />     .计次循环尾 ()<br />     写到内存 ({ 0 }, 数据地址 ＋ 写入位置, 1)  ' 写入文本终止符<br /> .否则<br />     .计次循环首 (取数组成员数 (数组文本), i)  ' 不过滤重复的<br />         _文本叠加_参数版_ASM (数组文本 <i>, 数据地址, 写入位置)<br />         写入位置 ＝ 写入位置 ＋ 数组长度 <i><br />     .计次循环尾 ()<br /> .如果结束<br /> 返回 (返回文本)

cf2006a

1101672929 发表于 2018-8-22 00:16
如果我没记错的话,这个代码快速文本的代码是我写的
我再写一个速度快一倍的你玩玩..
如果你考虑到需要过 ...

优化了下好像又快了一点点！去掉 取指针 和 复制内存 代码不变 代码少了 速度又不降

cf2006a

1101672929 发表于 2018-8-22 00:16
如果我没记错的话,这个代码快速文本的代码是我写的
我再写一个速度快一倍的你玩玩..
如果你考虑到需要过 ...

谢了，这个快一倍的方法和快文一样&#128522;，收下了

cf2006a

1101672929 发表于 2018-8-22 00:16
如果我没记错的话,这个代码快速文本的代码是我写的
我再写一个速度快一倍的你玩玩..
如果你考虑到需要过 ...

节点百万数据就卡死，千万已经跑不动了，所以易节点去重复不好用

蜗牛人生

如果我没记错的话,这个代码快速文本的代码是我写的
我再写一个速度快一倍的你玩玩..
如果你考虑到需要过滤重复的话,我推荐你用哈希表,特别是E2EE支持库的"存取键值表"特别好使!

代码如下:

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
i	整数型
g	文本型		1000
t	整数型
结果	文本型

计次循环首 (1000, i)
g [i] ＝ 到文本 (取随机数 (1, 2))
计次循环尾 ()
调试输出 (“开始”)
t ＝ 取启动时间 ()
结果 ＝ 数组叠加 (g, 假)
调试输出 (取启动时间 () － t)
信息框 (结果, 0, , )
调试输出 (“开始”)
t ＝ 取启动时间 ()
结果 ＝ 数组叠加_快速 (g)
调试输出 (取启动时间 () － t)

子程序名	返回值类型	公开	备 注
数组叠加_快速	文本型
参数名	类 型	参考	可空	数组	备 注
数组文本	文本型

变量名	类 型	静态	数组	备 注
快速	快速文本对象
i
总长度

计次循环首 (取数组成员数 (数组文本), i)
总长度 ＝ 总长度 ＋ 取文本长度 (数组文本 [i])
计次循环尾 ()
快速.置内存增量 (总长度)
计次循环首 (取数组成员数 (数组文本), i)
快速.添加 (数组文本 [i])
计次循环尾 ()
返回 (快速.取文本 (, ))

子程序名	返回值类型	公开	备 注
数组叠加	文本型		比快速文本快一倍左右吧
参数名	类 型	参考	可空	数组	备 注
数组文本	文本型
过滤重复	逻辑型				真为过滤掉重复的文本

变量名	类 型	静态	数组	备 注
数组长度	整数型		0
i	整数型
返回文本	文本型
写入位置	整数型
总长度	整数型
数据地址	整数型
节点	节点
是否存在	逻辑型

重定义数组 (数组长度, 假, 取数组成员数 (数组文本))
计次循环首 (取数组成员数 (数组文本), i)
数组长度 [i] ＝ _取文本长度 (数组文本 [i])
总长度 ＝ 总长度 ＋ 数组长度 [i]
计次循环尾 ()
返回文本 ＝ 取空白文本 (总长度)
数据地址 ＝ _取文本指针 (返回文本)
如果 (过滤重复)
计次循环首 (取数组成员数 (数组文本), i)  ' 这里自己用哈希表判断是否重复了,个人推荐"E2EE支持库"里的"存取键值表",这里为了大家都能运行,直接使用节点
如果真 (节点.取逻辑值 (数组文本 [i], 是否存在) 且 是否存在)  ' 已经存在的,跳过
到循环尾 ()
节点.加入属性 (数组文本 [i], 真)
_复制内存 (数据地址, _取文本指针 (数组文本 [i]), 数组长度 [i])
数据地址 ＝ 数据地址 ＋ 数组长度 [i]
计次循环尾 ()
写到内存 ({ 0 }, 数据地址, 1)  ' 写入文本终止符


计次循环首 (取数组成员数 (数组文本), i)  ' 不过滤重复的
_复制内存 (数据地址, _取文本指针 (数组文本 [i]), 数组长度 [i])
数据地址 ＝ 数据地址 ＋ 数组长度 [i]
计次循环尾 ()
返回 (返回文本)

子程序名	返回值类型	公开	备 注
_取文本指针	整数型		相当于 取变量数据地址()
参数名	类 型	参考	可空	数组	备 注
文本	文本型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
_取文本长度	整数型		取文本型数据的长度
参数名	类 型	参考	可空	数组	备 注
文本	文本型				参数值指定欲检查其长度的文本数据。

变量名	类 型	静态	数组	备 注
文本指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 141, 112, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 240, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
_复制内存			用法跟:RtlMoveMemory 一致
参数名	类 型	参考	可空	数组	备 注
被写的指针	整数型				目标指针
指针	整数型				原指针
长度	整数型				长度

置入代码 ({ 86, 87, 139, 117, 12, 139, 125, 8, 139, 77, 16, 252, 59, 247, 118, 26, 139, 209, 131, 226, 3, 193, 233, 2, 243, 165, 11, 202, 117, 2, 235, 2, 243, 164, 95, 94, 201, 194, 12, 0, 144, 144, 116, 246, 139, 199, 43, 198, 59, 200, 118, 220, 253, 3, 241, 3, 249, 78, 79, 243, 164, 252, 235, 226 })

i支持库列表	支持库注释
spec	特殊功能支持库
commobj	通用对象支持库
EDataStructure	数据结构支持库

.版本 2<br /> .支持库 spec<br /> .支持库 commobj<br /> .支持库 EDataStructure<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 i, 整数型<br /> .局部变量 g, 文本型, , "1000"<br /> .局部变量 t, 整数型<br /> .局部变量 结果, 文本型<br /> <br /> <br /> .计次循环首 (1000, i)<br />     g <i> ＝ 到文本 (取随机数 (1, 2))<br /> .计次循环尾 ()<br /> <br /> <br /> 调试输出 (“开始”)<br /> t ＝ 取启动时间 ()<br /> 结果 ＝ 数组叠加 (g, 假)<br /> 调试输出 (取启动时间 () － t)<br /> 信息框 (结果, 0, , )<br /> <br /> 调试输出 (“开始”)<br /> t ＝ 取启动时间 ()<br /> 结果 ＝ 数组叠加_快速 (g)<br /> 调试输出 (取启动时间 () － t)<br /> <br /> .子程序 数组叠加_快速, 文本型<br /> .参数 数组文本, 文本型, 数组<br /> .局部变量 快速, 快速文本对象<br /> .局部变量 i<br /> .局部变量 总长度<br /> <br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     总长度 ＝ 总长度 ＋ 取文本长度 (数组文本 <i>)<br /> .计次循环尾 ()<br /> 快速.置内存增量 (总长度)<br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     快速.添加 (数组文本 <i>)<br /> .计次循环尾 ()<br /> 返回 (快速.取文本 (, ))<br /> <br /> .子程序 数组叠加, 文本型, , 比快速文本快一倍左右吧<br /> .参数 数组文本, 文本型, 数组<br /> .参数 过滤重复, 逻辑型, 可空, 真为过滤掉重复的文本<br /> .局部变量 数组长度, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 返回文本, 文本型<br /> .局部变量 写入位置, 整数型<br /> .局部变量 总长度, 整数型<br /> .局部变量 数据地址, 整数型<br /> .局部变量 节点, 节点<br /> .局部变量 是否存在, 逻辑型<br /> <br /> 重定义数组 (数组长度, 假, 取数组成员数 (数组文本))<br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     数组长度 <i> ＝ _取文本长度 (数组文本 <i>)<br />     总长度 ＝ 总长度 ＋ 数组长度 <i><br /> .计次循环尾 ()<br /> 返回文本 ＝ 取空白文本 (总长度)<br /> 数据地址 ＝ _取文本指针 (返回文本)<br /> .如果 (过滤重复)<br />     .计次循环首 (取数组成员数 (数组文本), i)  ' 这里自己用哈希表判断是否重复了,个人推荐"E2EE支持库"里的"存取键值表",这里为了大家都能运行,直接使用节点<br />         .如果真 (节点.取逻辑值 (数组文本 <i>, 是否存在) 且 是否存在)  ' 已经存在的,跳过<br />             到循环尾 ()<br />         .如果真结束<br />         节点.加入属性 (数组文本 <i>, 真)<br />         _复制内存 (数据地址, _取文本指针 (数组文本 <i>), 数组长度 <i>)<br />         数据地址 ＝ 数据地址 ＋ 数组长度 <i><br />     .计次循环尾 ()<br />     写到内存 ({ 0 }, 数据地址, 1)  ' 写入文本终止符<br /> .否则<br /> <br />     .计次循环首 (取数组成员数 (数组文本), i)  ' 不过滤重复的<br />         _复制内存 (数据地址, _取文本指针 (数组文本 <i>), 数组长度 <i>)<br />         数据地址 ＝ 数据地址 ＋ 数组长度 <i><br />     .计次循环尾 ()<br /> <br /> .如果结束<br /> 返回 (返回文本)<br /> <br /> .子程序 _取文本指针, 整数型, , 相当于 取变量数据地址()<br /> .参数 文本, 文本型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 _取文本长度, 整数型, , 取文本型数据的长度<br /> .参数 文本, 文本型, , 参数值指定欲检查其长度的文本数据。<br /> .局部变量 文本指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 141, 112, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 240, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 _复制内存, , , 用法跟:RtlMoveMemory 一致<br /> .参数 被写的指针, 整数型, , 目标指针<br /> .参数 指针, 整数型, , 原指针<br /> .参数 长度, 整数型, , 长度<br /> <br /> 置入代码 ({ 86, 87, 139, 117, 12, 139, 125, 8, 139, 77, 16, 252, 59, 247, 118, 26, 139, 209, 131, 226, 3, 193, 233, 2, 243, 165, 11, 202, 117, 2, 235, 2, 243, 164, 95, 94, 201, 194, 12, 0, 144, 144, 116, 246, 139, 199, 43, 198, 59, 200, 118, 220, 253, 3, 241, 3, 249, 78, 79, 243, 164, 252, 235, 226 })

蜗牛人生

如果我没记错的话,这个代码快速文本的代码是我写的
其实,你的代码只要稍微改一下,效率就高了!

代码如下:

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
i	整数型
g	文本型		1000
t	整数型
结果	文本型

计次循环首 (1000, i)
g [i] ＝ 到文本 (取随机数 (1, 2))
计次循环尾 ()
调试输出 (“开始”)
t ＝ 取启动时间 ()
结果 ＝ 数组叠加 (g, 假)
调试输出 (取启动时间 () － t)
信息框 (结果, 0, , )
调试输出 (“开始”)
t ＝ 取启动时间 ()
结果 ＝ 数组叠加_快速 (g)
调试输出 (取启动时间 () － t)

子程序名	返回值类型	公开	备 注
数组叠加_快速	文本型
参数名	类 型	参考	可空	数组	备 注
数组文本	文本型

变量名	类 型	静态	数组	备 注
快速	快速文本对象
i
总长度

计次循环首 (取数组成员数 (数组文本), i)
总长度 ＝ 总长度 ＋ 取文本长度 (数组文本 [i])
计次循环尾 ()
快速.置内存增量 (总长度)
计次循环首 (取数组成员数 (数组文本), i)
快速.添加 (数组文本 [i])
计次循环尾 ()
返回 (快速.取文本 (, ))

子程序名	返回值类型	公开	备 注
数组叠加	文本型		比快速文本快一倍左右吧
参数名	类 型	参考	可空	数组	备 注
数组文本	文本型
过滤重复	逻辑型				真为过滤掉重复的文本

变量名	类 型	静态	数组	备 注
数组长度	整数型		0
i	整数型
返回文本	文本型
写入位置	整数型
总长度	整数型
数据地址	整数型
节点	节点
是否存在	逻辑型

重定义数组 (数组长度, 假, 取数组成员数 (数组文本))
计次循环首 (取数组成员数 (数组文本), i)
数组长度 [i] ＝ _取文本长度 (数组文本 [i])
总长度 ＝ 总长度 ＋ 数组长度 [i]
计次循环尾 ()
返回文本 ＝ 取空白文本 (总长度)
数据地址 ＝ _取文本指针 (返回文本)
如果 (过滤重复)
计次循环首 (取数组成员数 (数组文本), i)  ' 这里自己用哈希表判断是否重复了,个人推荐"E2EE支持库"里的"存取键值表",这里为了大家都能运行,直接使用节点
如果真 (节点.取逻辑值 (数组文本 [i], 是否存在) 且 是否存在)  ' 已经存在的,跳过
到循环尾 ()
节点.加入属性 (数组文本 [i], 真)
_复制内存 (数据地址, _取文本指针 (数组文本 [i]), 数组长度 [i])
数据地址 ＝ 数据地址 ＋ 数组长度 [i]
计次循环尾 ()
写到内存 ({ 0 }, 数据地址, 1)  ' 写入文本终止符


计次循环首 (取数组成员数 (数组文本), i)  ' 不过滤重复的
_复制内存 (数据地址, _取文本指针 (数组文本 [i]), 数组长度 [i])
数据地址 ＝ 数据地址 ＋ 数组长度 [i]
计次循环尾 ()
返回 (返回文本)

子程序名	返回值类型	公开	备 注
_取文本指针	整数型		相当于 取变量数据地址()
参数名	类 型	参考	可空	数组	备 注
文本	文本型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
_取文本长度	整数型		取文本型数据的长度
参数名	类 型	参考	可空	数组	备 注
文本	文本型				参数值指定欲检查其长度的文本数据。

变量名	类 型	静态	数组	备 注
文本指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 141, 112, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 240, 201, 194, 4, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
_复制内存			用法跟:RtlMoveMemory 一致
参数名	类 型	参考	可空	数组	备 注
被写的指针	整数型				目标指针
指针	整数型				原指针
长度	整数型				长度

置入代码 ({ 86, 87, 139, 117, 12, 139, 125, 8, 139, 77, 16, 252, 59, 247, 118, 26, 139, 209, 131, 226, 3, 193, 233, 2, 243, 165, 11, 202, 117, 2, 235, 2, 243, 164, 95, 94, 201, 194, 12, 0, 144, 144, 116, 246, 139, 199, 43, 198, 59, 200, 118, 220, 253, 3, 241, 3, 249, 78, 79, 243, 164, 252, 235, 226 })

i支持库列表	支持库注释
spec	特殊功能支持库
commobj	通用对象支持库
EDataStructure	数据结构支持库

.版本 2<br /> .支持库 spec<br /> .支持库 commobj<br /> .支持库 EDataStructure<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 i, 整数型<br /> .局部变量 g, 文本型, , "1000"<br /> .局部变量 t, 整数型<br /> .局部变量 结果, 文本型<br /> <br /> <br /> .计次循环首 (1000, i)<br />     g <i> ＝ 到文本 (取随机数 (1, 2))<br /> .计次循环尾 ()<br /> <br /> <br /> 调试输出 (“开始”)<br /> t ＝ 取启动时间 ()<br /> 结果 ＝ 数组叠加 (g, 假)<br /> 调试输出 (取启动时间 () － t)<br /> 信息框 (结果, 0, , )<br /> <br /> 调试输出 (“开始”)<br /> t ＝ 取启动时间 ()<br /> 结果 ＝ 数组叠加_快速 (g)<br /> 调试输出 (取启动时间 () － t)<br /> <br /> .子程序 数组叠加_快速, 文本型<br /> .参数 数组文本, 文本型, 数组<br /> .局部变量 快速, 快速文本对象<br /> .局部变量 i<br /> .局部变量 总长度<br /> <br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     总长度 ＝ 总长度 ＋ 取文本长度 (数组文本 <i>)<br /> .计次循环尾 ()<br /> 快速.置内存增量 (总长度)<br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     快速.添加 (数组文本 <i>)<br /> .计次循环尾 ()<br /> 返回 (快速.取文本 (, ))<br /> <br /> .子程序 数组叠加, 文本型, , 比快速文本快一倍左右吧<br /> .参数 数组文本, 文本型, 数组<br /> .参数 过滤重复, 逻辑型, 可空, 真为过滤掉重复的文本<br /> .局部变量 数组长度, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 返回文本, 文本型<br /> .局部变量 写入位置, 整数型<br /> .局部变量 总长度, 整数型<br /> .局部变量 数据地址, 整数型<br /> .局部变量 节点, 节点<br /> .局部变量 是否存在, 逻辑型<br /> <br /> 重定义数组 (数组长度, 假, 取数组成员数 (数组文本))<br /> .计次循环首 (取数组成员数 (数组文本), i)<br />     数组长度 <i> ＝ _取文本长度 (数组文本 <i>)<br />     总长度 ＝ 总长度 ＋ 数组长度 <i><br /> .计次循环尾 ()<br /> 返回文本 ＝ 取空白文本 (总长度)<br /> 数据地址 ＝ _取文本指针 (返回文本)<br /> .如果 (过滤重复)<br />     .计次循环首 (取数组成员数 (数组文本), i)  ' 这里自己用哈希表判断是否重复了,个人推荐"E2EE支持库"里的"存取键值表",这里为了大家都能运行,直接使用节点<br />         .如果真 (节点.取逻辑值 (数组文本 <i>, 是否存在) 且 是否存在)  ' 已经存在的,跳过<br />             到循环尾 ()<br />         .如果真结束<br />         节点.加入属性 (数组文本 <i>, 真)<br />         _复制内存 (数据地址, _取文本指针 (数组文本 <i>), 数组长度 <i>)<br />         数据地址 ＝ 数据地址 ＋ 数组长度 <i><br />     .计次循环尾 ()<br />     写到内存 ({ 0 }, 数据地址, 1)  ' 写入文本终止符<br /> .否则<br /> <br />     .计次循环首 (取数组成员数 (数组文本), i)  ' 不过滤重复的<br />         _复制内存 (数据地址, _取文本指针 (数组文本 <i>), 数组长度 <i>)<br />         数据地址 ＝ 数据地址 ＋ 数组长度 <i><br />     .计次循环尾 ()<br /> <br /> .如果结束<br /> 返回 (返回文本)<br /> <br /> .子程序 _取文本指针, 整数型, , 相当于 取变量数据地址()<br /> .参数 文本, 文本型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 _取文本长度, 整数型, , 取文本型数据的长度<br /> .参数 文本, 文本型, , 参数值指定欲检查其长度的文本数据。<br /> .局部变量 文本指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 141, 112, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 240, 201, 194, 4, 0 })<br /> 返回 (0)<br /> <br /> .子程序 _复制内存, , , 用法跟:RtlMoveMemory 一致<br /> .参数 被写的指针, 整数型, , 目标指针<br /> .参数 指针, 整数型, , 原指针<br /> .参数 长度, 整数型, , 长度<br /> <br /> 置入代码 ({ 86, 87, 139, 117, 12, 139, 125, 8, 139, 77, 16, 252, 59, 247, 118, 26, 139, 209, 131, 226, 3, 193, 233, 2, 243, 165, 11, 202, 117, 2, 235, 2, 243, 164, 95, 94, 201, 194, 12, 0, 144, 144, 116, 246, 139, 199, 43, 198, 59, 200, 118, 220, 253, 3, 241, 3, 249, 78, 79, 243, 164, 252, 235, 226 })

小虎来了

谢谢辛苦分享