[精易模块] 数组_合并() 命令 建议 增加 或 改进

汉族

我也是看求助区 看到 这个   数组_合并    但是 我发现 这命令  估计 就是 累加 方式   


行数* 30173
模块用时* 21.88秒
行数* 7.5万
内存用时* 100毫秒或以下

7万多行   累加方式   直接半天没反应。 很多文本这样处理~ 拖在速度上……影响了我们的效率！


最新！ 最新！  最新！ 数组_合并_内存.e (1.6 MB, 下载次数: 5)

2020-12-10 23:35 上传

点击文件名下载附件    “自带清理地址空间数据”   我静态编译测试稳定

操作演示：



静态编译后操作内存大小控制：





最新！ 最新！  最新！       以下以  最新的代码显示为主，楼层反馈 那会儿 有事，这会儿 来优化测试了一些问题 优化一下。  

  

子程序名	返回值类型	公开	备 注
数组_合并_内存	文本型		内存操作只要10-30毫秒  默认为20兆数据
参数名	类 型	参考	可空	数组	备 注
数组	文本型
合并字符	文本型				可以空 默认为   ,  单字符 逗号
返回指针					用于释放内存空间用  GlobalFree (返回指针)   用不用都没关系 自带了

变量名	类 型	静态	数组	备 注
j	整数型
str				关于  静态 不静态  不重要  子程序 返回处理
cd	整数型
text	文本型

str ＝ 内存_申请内存 (20 × 1024 × 1024)  ' 由于文本累加速度多了 会很慢，所以用 内存写  在 20兆的数据中写 数据 就很快。
如果真 (是否为空 (合并字符))
合并字符 ＝ “,”
计次循环首 (取数组成员数 (数组), j)
如果真 (j ≥ 取数组成员数 (数组))
合并字符 ＝ “”
写到内存 (数组 [j] ＋ 合并字符, str ＋ cd, 20 × 1024 × 1024)
cd ＝ cd ＋ 取文本长度 (数组 [j] ＋ 合并字符)
计次循环尾 ()
返回指针 ＝ str
线程_启动 (&释放, str)
返回 (指针_到文本 (str))

子程序名	返回值类型	公开	备 注
释放			自带释放
参数名	类 型	参考	可空	数组	备 注
s

延时 (500)  ' 时间 300   半秒  1秒 这样 都行 别太少  不然会蹦
GlobalFree (s)

.版本 2<br /> <br /> .子程序 数组_合并_内存, 文本型, , 内存操作只要10-30毫秒  默认为20兆数据<br /> .参数 数组, 文本型, 数组<br /> .参数 合并字符, 文本型, 可空,   可以空 默认为   ,  单字符 逗号<br /> .参数 返回指针, , 参考 可空, 用于释放内存空间用  GlobalFree (返回指针)   用不用都没关系 自带了<br /> .局部变量 j, 整数型<br /> .局部变量 str, , , , 关于  静态 不静态  不重要  子程序 返回处理  <br /> .局部变量 cd, 整数型<br /> .局部变量 text, 文本型<br /> <br /> str ＝ 内存_申请内存 (20 × 1024 × 1024)  ' 由于文本累加速度多了 会很慢，所以用 内存写  在 20兆的数据中写 数据 就很快。<br /> .如果真 (是否为空 (合并字符))<br />     合并字符 ＝ “,”<br /> .如果真结束<br /> .计次循环首 (取数组成员数 (数组), j)<br />     .如果真 (j ≥ 取数组成员数 (数组))<br />         合并字符 ＝ “”<br />     .如果真结束<br />     写到内存 (数组 [j] ＋ 合并字符, str ＋ cd, 20 × 1024 × 1024)<br />     cd ＝ cd ＋ 取文本长度 (数组 [j] ＋ 合并字符)<br /> .计次循环尾 ()<br /> 返回指针 ＝ str<br /> 线程_启动 (&释放, str)<br /> 返回 (指针_到文本 (str))<br /> <br /> .子程序 释放, , , 自带释放<br /> .参数 s<br /> <br /> 延时 (500)  ' 时间 300   半秒  1秒 这样 都行 别太少  不然会蹦<br /> GlobalFree (s)

Mr.Yang

又发现了一个BUG.

原因是"指针_到文本"内调用的"lstrlenA"导致指针长度有误.返回文本相差了八位.

用"LocalSize"替换可以解决.

Mr.Yang

写到内存 (数组 [j] ＋ 合并字符, str ＋ cd, 20 × 1024 × 1024)

这样长度越界啊.数据量大于20M 碰巧就崩了.

  

子程序名	返回值类型	公开	备 注
数组_合并_内存	文本型		内存操作只要10-30毫秒  默认为20兆数据
参数名	类 型	参考	可空	数组	备 注
数组	文本型
合并字符	文本型				可以空 默认为   ,  单字符 逗号
返回指针					用于释放内存空间用  GlobalFree (返回指针)   用不用都没关系 自带了

变量名	类 型	静态	数组	备 注
j	整数型
str				关于  静态 不静态  不重要  子程序 返回处理
cd	整数型
text	文本型
数据长度	整数型

str ＝ 内存_申请内存 (20 × 1024 × 1024)  ' 由于文本累加速度多了 会很慢，所以用 内存写  在 20兆的数据中写 数据 就很快。
如果真 (是否为空 (合并字符))
合并字符 ＝ “,”
计次循环首 (取数组成员数 (数组), j)
如果 (取数组成员数 (数组) ＝ j)
数据长度 ＝ 取文本长度 (数组 [j])
数据长度 ＝ 取文本长度 (数组 [j] ＋ 合并字符)
写到内存 (数组 [j] ＋ 合并字符, str ＋ cd, 数据长度)
cd ＝ cd ＋ 数据长度
计次循环尾 ()
返回指针 ＝ str
线程_启动 (&释放, str)
返回 (指针_到文本 (str))

.版本 2<br /> <br /> .子程序 数组_合并_内存, 文本型, , 内存操作只要10-30毫秒  默认为20兆数据<br /> .参数 数组, 文本型, 数组<br /> .参数 合并字符, 文本型, 可空, 可以空 默认为   ,  单字符 逗号<br /> .参数 返回指针, , 参考 可空, 用于释放内存空间用  GlobalFree (返回指针)   用不用都没关系 自带了<br /> .局部变量 j, 整数型<br /> .局部变量 str, , , , 关于  静态 不静态  不重要  子程序 返回处理<br /> .局部变量 cd, 整数型<br /> .局部变量 text, 文本型<br /> .局部变量 数据长度, 整数型<br /> <br /> str ＝ 内存_申请内存 (20 × 1024 × 1024)  ' 由于文本累加速度多了 会很慢，所以用 内存写  在 20兆的数据中写 数据 就很快。<br /> .如果真 (是否为空 (合并字符))<br />     合并字符 ＝ “,”<br /> .如果真结束<br /> .计次循环首 (取数组成员数 (数组), j)<br />     .如果 (取数组成员数 (数组) ＝ j)<br />         数据长度 ＝ 取文本长度 (数组 [j])<br />     .否则<br />         数据长度 ＝ 取文本长度 (数组 [j] ＋ 合并字符)<br />     .如果结束<br />     写到内存 (数组 [j] ＋ 合并字符, str ＋ cd, 数据长度)<br />     cd ＝ cd ＋ 数据长度<br /> .计次循环尾 ()<br /> 返回指针 ＝ str<br /> 线程_启动 (&释放, str)<br /> 返回 (指针_到文本 (str))

这样写应该会好一点.而且尾行也不需要改合并字符.

850536360

你的没有释放内存，试了循环100次，程序直接崩溃。

数组_合并_内存.e (1.61 MB, 下载次数: 3)

2020-12-10 23:41 上传

点击文件名下载附件
这样子比较好

  

子程序名	返回值类型	公开	备 注
数组_合并_内存2	文本型
参数名	类 型	参考	可空	数组	备 注
数组	文本型
合并字符	文本型

变量名	类 型	静态	数组	备 注
i
j
文本长度	整数型		0
总长度	整数型
成员数	整数型
数组指针	整数型
合并字符指针	整数型
合并字符长度	整数型
返回文本指针	整数型
返回文本	文本型

成员数 ＝ 取数组成员数 (数组)
如果真 (成员数 ＝ 0)
返回 (“”)
数组指针 ＝ 取变量数据地址 (数组)
合并字符指针 ＝ 取变量数据地址 (合并字符)
合并字符长度 ＝ 取文本长度 (合并字符)
' 计算文本长度
j ＝ 0
重定义数组 (文本长度, 假, 成员数)
计次循环首 (成员数, i)
文本长度 [i] ＝ lstrlenA (指针_到整数 (数组指针 ＋ j))
总长度 ＝ 总长度 ＋ 文本长度 [i]
j ＝ j ＋ 4
计次循环尾 ()
总长度 ＝ 总长度 ＋ 合并字符长度 × 成员数 ＋ 1
返回文本指针 ＝ 内存_申请内存 (总长度)
写到内存 (返回文本指针, 取变量地址 (返回文本), )  ' 相当于局部变量，会自动释放
j ＝ 0
计次循环首 (成员数, i)
RtlMoveMemory (返回文本指针, 指针_到整数 (数组指针 ＋ j), 文本长度 [i])
返回文本指针 ＝ 返回文本指针 ＋ 文本长度 [i]
如果真 (合并字符长度 ≠ 0)
RtlMoveMemory (返回文本指针, 合并字符指针, 合并字符长度)
返回文本指针 ＝ 返回文本指针 ＋ 合并字符长度
j ＝ j ＋ 4
计次循环尾 ()
返回 (返回文本)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 数组_合并_内存2, 文本型<br /> .参数 数组, 文本型, 数组<br /> .参数 合并字符, 文本型, 可空<br /> .局部变量 i<br /> .局部变量 j<br /> .局部变量 文本长度, 整数型, , "0"<br /> .局部变量 总长度, 整数型<br /> .局部变量 成员数, 整数型<br /> .局部变量 数组指针, 整数型<br /> .局部变量 合并字符指针, 整数型<br /> .局部变量 合并字符长度, 整数型<br /> .局部变量 返回文本指针, 整数型<br /> .局部变量 返回文本, 文本型<br /> <br /> 成员数 ＝ 取数组成员数 (数组)<br /> .如果真 (成员数 ＝ 0)<br />     返回 (“”)<br /> .如果真结束<br /> 数组指针 ＝ 取变量数据地址 (数组)<br /> 合并字符指针 ＝ 取变量数据地址 (合并字符)<br /> 合并字符长度 ＝ 取文本长度 (合并字符)<br /> ' 计算文本长度<br /> j ＝ 0<br /> 重定义数组 (文本长度, 假, 成员数)<br /> .计次循环首 (成员数, i)<br />     文本长度 <i> ＝ lstrlenA (指针_到整数 (数组指针 ＋ j))<br />     总长度 ＝ 总长度 ＋ 文本长度 <i><br />     j ＝ j ＋ 4<br /> .计次循环尾 ()<br /> 总长度 ＝ 总长度 ＋ 合并字符长度 × 成员数 ＋ 1<br /> <br /> 返回文本指针 ＝ 内存_申请内存 (总长度)<br /> 写到内存 (返回文本指针, 取变量地址 (返回文本), )  ' 相当于局部变量，会自动释放<br /> j ＝ 0<br /> .计次循环首 (成员数, i)<br />     RtlMoveMemory (返回文本指针, 指针_到整数 (数组指针 ＋ j), 文本长度 <i>)<br />     返回文本指针 ＝ 返回文本指针 ＋ 文本长度 <i><br />     .如果真 (合并字符长度 ≠ 0)<br />         RtlMoveMemory (返回文本指针, 合并字符指针, 合并字符长度)<br />         返回文本指针 ＝ 返回文本指针 ＋ 合并字符长度<br />     .如果真结束<br />     j ＝ j ＋ 4<br /> .计次循环尾 ()<br /> 返回 (返回文本)

神女软件定制

不应该使用系统_处理事件

神女软件定制

如果真 (是否为空 (合并字符))，不应放在循环里

一剑磨十年

感谢分享

53770zhang

收藏了,这个合并去重复了吗