文本快速处理方法

a437669347

  

窗口程序集名	保 留	保 留	备 注
程序集1
变量名	类 型	数组	备 注
集_许可	整数型
集_得到的字节集数组	字节集	0
集_每个线程执行数	整数型
集_状态	状态分类	0
集_状态2	状态分类	0
集_执行线程数	整数型
集_shuzhi	整数型
集_总行数	整数型

子程序名	返回值类型	公开	备 注
_启动子程序	整数型		请在本子程序中放置易模块初始化代码

变量名	类 型	静态	数组	备 注
路径	文本型
ret	双精度小数型

集_许可 ＝ 创建进入许可证 ()
路径 ＝ 取运行目录 () ＋ “\”
创建目录 (路径 ＋ “分类结果”)
ret ＝ 文本状态分类 (读入文件 (路径 ＋ “测试文本.txt”), “帐号回收-帐号冻结-帐号正常-改密解冻-永久冻结”, 路径 ＋ “分类结果\”)
信息框 (到文本 (“耗时:” ＋ 到文本 (ret) ＋ “秒”), 0, , )
_临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
_临时子程序

' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。

子程序名	返回值类型	公开	备 注
文本状态分类	双精度小数型		成功返回所需要的的秒数
参数名	类 型	参考	可空	数组	备 注
参_原xx字节集	字节集
参_状态文本	文本型				支持多个文本如  帐号正常-帐号冻结
参_需要写到的路径	文本型				注意后面要带\

变量名	类 型	静态	数组	备 注
局_文本数组	文本型		0
局_成员	整数型
局_c	整数型
局_s	整数型
局_字节集对象	快速字节集对象
局_xx	文本型
局_地址	整数型

如果真 (寻找文本 (参_状态文本, “-”, , 假) ＝ -1)
参_状态文本 ＝ 参_状态文本 ＋ “-”
局_文本数组 ＝ 分割文本 (参_状态文本, “-”, )
局_成员 ＝ 取数组成员数 (局_文本数组)
清除数组 (集_状态)
清除数组 (集_状态2)  ' 因多线程内操作原【集_状态】 '所以定义两个,用于复制用,如复制原状态会   崩！崩！崩！
如果真 (局_成员 ＞ 0)
重定义数组 (集_状态, 假, 局_成员)
重定义数组 (集_状态2, 假, 局_成员)
计次循环首 (局_成员, 局_c)
集_状态 [局_c].状态文本 ＝ 局_文本数组 [局_c]
集_状态2 [局_c].状态文本 ＝ 局_文本数组 [局_c]
计次循环尾 ()
局_字节集对象.置字节集 ({  })
局_字节集对象.置字节集 (参_原xx字节集)
集_得到的字节集数组 ＝ 局_字节集对象.分割字节集 ({ 13, 10 }, )
局_成员 ＝ 取数组成员数 (集_得到的字节集数组)
集_总行数 ＝ 局_成员
如果 (局_成员 ＞ 20)  ' 我电脑是20线程的所以就定为20的了  你们核心没有达到也没关系超标也无所谓
集_执行线程数 ＝ 20
集_每个线程执行数 ＝ 取整 (局_成员 ÷ 20)

集_执行线程数 ＝ 1
集_每个线程执行数 ＝ 局_成员

局_s ＝ 取启动时间 ()
集_shuzhi ＝ 0
计次循环首 (集_执行线程数, 局_c)
集_shuzhi ＝ 集_shuzhi ＋ 1
局_xx ＝ 到文本 (集_每个线程执行数) ＋ “-” ＋ 到文本 (局_c － 1)
局_地址 ＝ 申请内存 (取文本长度 (局_xx) ＋ 4, 真)
写到内存 (局_xx, 局_地址, 取文本长度 (局_xx))
启动线程 (&处理线程, 局_地址, )
计次循环尾 ()
循环判断首 ()
延时 (20)
如果真 (集_shuzhi ≤ 0)
跳出循环 ()

循环判断尾 (1 ＝ 1)
计次循环首 (取数组成员数 (集_状态), 局_c)
集_状态 [局_c].原文本.写到文件 (参_需要写到的路径 ＋ 集_状态 [局_c].状态文本 ＋ “.txt”)
计次循环尾 ()
返回 (到数值 ( (取启动时间 () － 局_s) ÷ 1000))
返回 (0)

子程序名	返回值类型	公开	备 注
处理线程
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型

变量名	类 型	静态	数组	备 注
局_增加	整数型
局_c	整数型
局_成员	整数型
局_b	整数型
局_字节集	字节集
局_状态分类	状态分类		0
局_临时地址	整数型
局_文本	文本型
局_asd	文本型		0
局_循环次数	整数型
局_循坏开始	整数型

进入许可区 (集_许可)
局_临时地址 ＝ 参_地址
退出许可区 (集_许可)
局_文本 ＝ 指针到文本 (局_临时地址)
释放内存 (局_临时地址)
局_asd ＝ 分割文本 (局_文本, “-”, )
局_循环次数 ＝ 到整数 (局_asd [1])
局_循坏开始 ＝ 到整数 (局_asd [2])
如果 (局_循坏开始 ＋ 1 ＝ 集_执行线程数)
局_增加 ＝ 局_循环次数 × 局_循坏开始
局_循环次数 ＝ 集_总行数 － 局_增加
局_增加 ＝ 局_循环次数 × 局_循坏开始
复制数组 (局_状态分类, 集_状态2)
局_成员 ＝ 取数组成员数 (局_状态分类)
计次循环首 (局_循环次数, 局_c)
局_字节集 ＝ 集_得到的字节集数组 [局_增加 ＋ 局_c]
计次循环首 (局_成员, 局_b)
如果真 (寻找字节集 (局_字节集, 到字节集 (局_状态分类 [局_b].状态文本), ) ≠ -1)
局_状态分类 [局_b].原文本.添加 (局_字节集 ＋ { 13, 10 })
跳出循环 ()

计次循环尾 ()
计次循环尾 ()
进入许可区 (集_许可)
计次循环首 (局_成员, 局_c)
集_状态 [局_c].原文本.添加 (局_状态分类 [局_c].原文本.取字节集 (, 局_状态分类 [局_c].原文本.取长度 ()))
计次循环尾 ()
集_shuzhi ＝ 集_shuzhi － 1
退出许可区 (集_许可)

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

.版本 2<br /> .支持库 EThread<br /> .支持库 commobj<br /> .支持库 spec<br /> <br /> .程序集 程序集1<br /> .程序集变量 集_许可, 整数型<br /> .程序集变量 集_得到的字节集数组, 字节集, , "0"<br /> .程序集变量 集_每个线程执行数, 整数型<br /> .程序集变量 集_状态, 状态分类, , "0"<br /> .程序集变量 集_状态2, 状态分类, , "0"<br /> .程序集变量 集_执行线程数, 整数型<br /> .程序集变量 集_shuzhi, 整数型<br /> .程序集变量 集_总行数, 整数型<br /> <br /> .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码<br /> .局部变量 路径, 文本型<br /> .局部变量 ret, 双精度小数型<br /> <br /> 集_许可 ＝ 创建进入许可证 ()<br /> 路径 ＝ 取运行目录 () ＋ “\”<br /> 创建目录 (路径 ＋ “分类结果”)<br /> ret ＝ 文本状态分类 (读入文件 (路径 ＋ “测试文本.txt”), “帐号回收-帐号冻结-帐号正常-改密解冻-永久冻结”, 路径 ＋ “分类结果\”)<br /> 信息框 (到文本 (“耗时:” ＋ 到文本 (ret) ＋ “秒”), 0, , )<br /> _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码<br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 _临时子程序<br /> <br /> ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。<br /> <br /> <br /> .子程序 文本状态分类, 双精度小数型, 公开, 成功返回所需要的的秒数<br /> .参数 参_原xx字节集, 字节集<br /> .参数 参_状态文本, 文本型, , 支持多个文本如  帐号正常-帐号冻结<br /> .参数 参_需要写到的路径, 文本型, , 注意后面要带\<br /> .局部变量 局_文本数组, 文本型, , "0"<br /> .局部变量 局_成员, 整数型<br /> .局部变量 局_c, 整数型<br /> .局部变量 局_s, 整数型<br /> .局部变量 局_字节集对象, 快速字节集对象<br /> .局部变量 局_xx, 文本型<br /> .局部变量 局_地址, 整数型<br /> <br /> .如果真 (寻找文本 (参_状态文本, “-”, , 假) ＝ -1)<br />     参_状态文本 ＝ 参_状态文本 ＋ “-”<br /> .如果真结束<br /> 局_文本数组 ＝ 分割文本 (参_状态文本, “-”, )<br /> 局_成员 ＝ 取数组成员数 (局_文本数组)<br /> 清除数组 (集_状态)<br /> 清除数组 (集_状态2)  ' 因多线程内操作原【集_状态】 '所以定义两个,用于复制用,如复制原状态会   崩！崩！崩！<br /> .如果真 (局_成员 ＞ 0)<br />     重定义数组 (集_状态, 假, 局_成员)<br />     重定义数组 (集_状态2, 假, 局_成员)<br />     .计次循环首 (局_成员, 局_c)<br />         集_状态 [局_c].状态文本 ＝ 局_文本数组 [局_c]<br />         集_状态2 [局_c].状态文本 ＝ 局_文本数组 [局_c]<br />     .计次循环尾 ()<br />     局_字节集对象.置字节集 ({  })<br />     局_字节集对象.置字节集 (参_原xx字节集)<br />     集_得到的字节集数组 ＝ 局_字节集对象.分割字节集 ({ 13, 10 }, )<br />     局_成员 ＝ 取数组成员数 (集_得到的字节集数组)<br />     集_总行数 ＝ 局_成员<br />     .如果 (局_成员 ＞ 20)  ' 我电脑是20线程的所以就定为20的了  你们核心没有达到也没关系超标也无所谓<br />         集_执行线程数 ＝ 20<br />         集_每个线程执行数 ＝ 取整 (局_成员 ÷ 20)<br /> <br />     .否则<br />         集_执行线程数 ＝ 1<br />         集_每个线程执行数 ＝ 局_成员<br />     .如果结束<br /> <br />     局_s ＝ 取启动时间 ()<br />     集_shuzhi ＝ 0<br />     .计次循环首 (集_执行线程数, 局_c)<br />         集_shuzhi ＝ 集_shuzhi ＋ 1<br />         局_xx ＝ 到文本 (集_每个线程执行数) ＋ “-” ＋ 到文本 (局_c － 1)<br />         局_地址 ＝ 申请内存 (取文本长度 (局_xx) ＋ 4, 真)<br />         写到内存 (局_xx, 局_地址, 取文本长度 (局_xx))<br />         启动线程 (&处理线程, 局_地址, )<br />     .计次循环尾 ()<br />     .循环判断首 ()<br />         延时 (20)<br />         .如果真 (集_shuzhi ≤ 0)<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .循环判断尾 (1 ＝ 1)<br />     .计次循环首 (取数组成员数 (集_状态), 局_c)<br />         集_状态 [局_c].原文本.写到文件 (参_需要写到的路径 ＋ 集_状态 [局_c].状态文本 ＋ “.txt”)<br />     .计次循环尾 ()<br />     返回 (到数值 ((取启动时间 () － 局_s) ÷ 1000))<br /> .如果真结束<br /> 返回 (0)<br /> <br /> .子程序 处理线程<br /> .参数 参_地址, 整数型<br /> .局部变量 局_增加, 整数型<br /> .局部变量 局_c, 整数型<br /> .局部变量 局_成员, 整数型<br /> .局部变量 局_b, 整数型<br /> .局部变量 局_字节集, 字节集<br /> .局部变量 局_状态分类, 状态分类, , "0"<br /> .局部变量 局_临时地址, 整数型<br /> .局部变量 局_文本, 文本型<br /> .局部变量 局_asd, 文本型, , "0"<br /> .局部变量 局_循环次数, 整数型<br /> .局部变量 局_循坏开始, 整数型<br /> <br /> 进入许可区 (集_许可)<br /> 局_临时地址 ＝ 参_地址<br /> 退出许可区 (集_许可)<br /> 局_文本 ＝ 指针到文本 (局_临时地址)<br /> 释放内存 (局_临时地址)<br /> 局_asd ＝ 分割文本 (局_文本, “-”, )<br /> 局_循环次数 ＝ 到整数 (局_asd [1])<br /> 局_循坏开始 ＝ 到整数 (局_asd [2])<br /> .如果 (局_循坏开始 ＋ 1 ＝ 集_执行线程数)<br />     局_增加 ＝ 局_循环次数 × 局_循坏开始<br />     局_循环次数 ＝ 集_总行数 － 局_增加<br /> .否则<br />     局_增加 ＝ 局_循环次数 × 局_循坏开始<br /> .如果结束<br /> 复制数组 (局_状态分类, 集_状态2)<br /> 局_成员 ＝ 取数组成员数 (局_状态分类)<br /> .计次循环首 (局_循环次数, 局_c)<br />     局_字节集 ＝ 集_得到的字节集数组 [局_增加 ＋ 局_c]<br />     .计次循环首 (局_成员, 局_b)<br />         .如果真 (寻找字节集 (局_字节集, 到字节集 (局_状态分类 [局_b].状态文本), ) ≠ -1)<br />             局_状态分类 [局_b].原文本.添加 (局_字节集 ＋ { 13, 10 })<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> 进入许可区 (集_许可)<br /> .计次循环首 (局_成员, 局_c)<br />     集_状态 [局_c].原文本.添加 (局_状态分类 [局_c].原文本.取字节集 (, 局_状态分类 [局_c].原文本.取长度 ()))<br /> .计次循环尾 ()<br /> 集_shuzhi ＝ 集_shuzhi － 1<br /> 退出许可区 (集_许可)

  

.xx类型 状态分类, 公开

数据类型名	公开	备 注
(未定义数据类型名)
成员名	类 型	传址	数组	备 注
状态文本	文本型
原文本	快速字节集对象

i支持库列表	支持库注释
commobj	通用对象支持库

.版本 2<br /> .支持库 commobj<br /> <br /> .xx类型 状态分类, 公开<br />     .成员 状态文本, 文本型<br />     .成员 原文本, 快速字节集对象

自己写的文本状态分类工具,处理的速度一般吧,100万只需要几秒,所有的分类都会分好


test.rar (4.48 KB, 下载次数: 56)

2020-2-24 15:13 上传

点击文件名下载附件 源码加例子,无模块,  我只写了分类,其他的重复什么之类的都可以用这种方法,就是把大xx分成一块一块处理的比较快.

小牛咪咪

TFXX

感谢分享~!

ruyan666

排序会打乱不

552233

支持开源~！感谢分享

w55304557

感谢分享了

逃离梦境

..............

linlin888

好东西！！！谢谢

外星星人

支持分享.感谢

列明

主要思路是多綫程分段分層處理原長文本。

幻月工作室

感觉......好实用啊，哈哈