超级列表框如何保存文件和读取文件

浮梦

想问一下各位大神 , 超级列表框 如何 读取文件 和 保存文件

我的数据是长文本 , 推荐用 ini 保存还是 txt保存?   

我想把超级列表框内的内容 按顺序  保存到本地文件txt ,  下次启动的时候自动读取txt  

保存格式(中间用 横线 隔开) 比如:

0 - 121313113 - xxxxxxxxx省略1000字...
1 - wqdwsasdas - xxxxxxxxx省略1000字...
2 - cassaccsasac - xxxxxxxxx省略1000字...




然后读取的时候 也按这个格式 完整读取 到 超级列表框里



补充内容 (2025-3-22 21:56):
数据内容 是有换行符的

aipca

浮梦 发表于 2025-3-22 21:54
我那些数据是有换行符的... 读取进去就错乱了 , 或者改成 每一行 生成一个txt 可以吗  , 分开存  ...

给一段你这个实例文本参考一下吧。估计分割不太好使，看看正则会不会好些

人杰啊

外部超级列表框有个 具体叫啥忘了你打开模块找找

算法艺术家

  

子程序名	返回值类型	公开	备 注
超级列表框_导入数据	整数型		将文本导入到超级列表框、行隔符为换行符，返回最后索引  空文本返回-1
参数名	类 型	参考	可空	数组	备 注
文本数据	文本型				到文本 (读入文件 (路径))
超级列表框	超级列表框
列隔符	文本型				列与列的分隔符号 只导入一列 不需要填写
是否保留原先数据	逻辑型				默认不保留

变量名	类 型	静态	数组	备 注
行组	文本型		0
列组	文本型		0
i	整数型
索引	整数型
n	整数型

如果真 (文本数据 ＝ “”)
返回 (-1)

行组 ＝ 分割文本 (文本数据, #换行符, )
超级列表框.可视 ＝ 假
超级列表框.禁止重画 ()
如果真 (是否保留原先数据 ＝ 假)
超级列表框.全部删除 ()

计次循环首 (取数组成员数 (行组), i)
列组 ＝ 分割文本 (行组 [i], 列隔符, )
索引 ＝ 超级列表框.插入表项 (, , , , , )
计次循环首 (取数组成员数 (列组), n)
超级列表框.置标题 (索引, n － 1, 列组 [n])
计次循环尾 ()
计次循环尾 ()
超级列表框.允许重画 ()
超级列表框.可视 ＝ 真
返回 (索引)

子程序名	返回值类型	公开	备 注
超级列表框_导出数据	文本型		以文本的方式写出列表的所有数据、#换行符分行
参数名	类 型	参考	可空	数组	备 注
超级列表框	超级列表框				选定需要导出的超级列表框、
分隔符	文本型				列与列的分隔符号

变量名	类 型	静态	数组	备 注
i	整数型
j	整数型
列数	整数型
行数	整数型
表头	文本型		0
列	文本型		0
行	文本型		0

行数 ＝ 超级列表框.取表项数 ()
列数 ＝ 超级列表框.取列数 ()
. ' 计次循环首 (列数, j)
' 加入成员 (表头, 超级列表框.取列标题 (j － 1))
. ' 计次循环尾 ()
' 加入成员 (行, 数组_合并_快速 (表头, 分隔符))
计次循环首 (行数, i)
清除数组 (列)
计次循环首 (列数, j)
加入成员 (列, 超级列表框.取标题 (i － 1, j － 1))
计次循环尾 ()
加入成员 (行, 数组_合并_快速 (列, 分隔符))
计次循环尾 ()
返回 (数组_合并_快速 (行, #换行符 ))

i支持库列表	支持库注释
iext	扩展界面支持库一

.版本 2<br /> .支持库 iext<br /> <br /> .子程序 超级列表框_导入数据, 整数型, 公开, 将文本导入到超级列表框、行隔符为换行符，返回最后索引  空文本返回-1<br /> .参数 文本数据, 文本型, , 到文本 (读入文件 (路径))<br /> .参数 超级列表框, 超级列表框, 参考<br /> .参数 列隔符, 文本型, 可空,  列与列的分隔符号 只导入一列 不需要填写<br /> .参数 是否保留原先数据, 逻辑型, 可空, 默认不保留<br /> .局部变量 行组, 文本型, , "0"<br /> .局部变量 列组, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 索引, 整数型<br /> .局部变量 n, 整数型<br /> <br /> <br /> .如果真 (文本数据 ＝ “”)<br />     返回 (-1)<br /> .如果真结束<br /> <br /> 行组 ＝ 分割文本 (文本数据, #换行符, )<br /> 超级列表框.可视 ＝ 假<br /> 超级列表框.禁止重画 ()<br /> <br /> .如果真 (是否保留原先数据 ＝ 假)<br />     超级列表框.全部删除 ()<br /> .如果真结束<br /> <br /> .计次循环首 (取数组成员数 (行组), i)<br />     列组 ＝ 分割文本 (行组 <i>, 列隔符, )<br />     索引 ＝ 超级列表框.插入表项 (, , , , , )<br />     .计次循环首 (取数组成员数 (列组), n)<br />         超级列表框.置标题 (索引, n － 1, 列组 [n])<br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> 超级列表框.允许重画 ()<br /> 超级列表框.可视 ＝ 真<br /> 返回 (索引)<br /> <br /> .子程序 超级列表框_导出数据, 文本型, 公开, 以文本的方式写出列表的所有数据、#换行符分行<br /> .参数 超级列表框, 超级列表框, , 选定需要导出的超级列表框、<br /> .参数 分隔符, 文本型, , 列与列的分隔符号<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> .局部变量 列数, 整数型<br /> .局部变量 行数, 整数型<br /> .局部变量 表头, 文本型, , "0"<br /> .局部变量 列, 文本型, , "0"<br /> .局部变量 行, 文本型, , "0"<br /> <br /> 行数 ＝ 超级列表框.取表项数 ()<br /> 列数 ＝ 超级列表框.取列数 ()<br /> <br /> .' 计次循环首 (列数, j)<br />     ' 加入成员 (表头, 超级列表框.取列标题 (j － 1))<br /> .' 计次循环尾 ()<br /> ' 加入成员 (行, 数组_合并_快速 (表头, 分隔符))<br /> .计次循环首 (行数, i)<br />     清除数组 (列)<br />     .计次循环首 (列数, j)<br />         加入成员 (列, 超级列表框.取标题 (i － 1, j － 1))<br />     .计次循环尾 ()<br />     加入成员 (行, 数组_合并_快速 (列, 分隔符))<br /> .计次循环尾 ()<br /> 返回 (数组_合并_快速 (行, #换行符))

补充内容 (2025-3-22 20:51):
.版本 2

写到文件 (文件路径, 到字节集 (超级列表框_导出数据 (超级列表框1, “ - ”)))

超级列表框_导入数据 (到文本 (读入文件 (文件路径)), 超级列...

算法艺术家

  

子程序名	返回值类型	公开	备 注
超级列表框_快速导入数据
参数名	类 型	参考	可空	数组	备 注
超级列表框	超级列表框
文件路径	文本型				路径优先
总文本	文本型				路径为空时导入文本
列隔符	文本型				默认#表格空格符
保留原有数据	逻辑型				默认不保留  如果保留 必须是没经过删除的数据 超列的删除是标记删除

变量名	类 型	静态	数组	备 注
字节集	快速字节集对象
文本	快速文本对象
行组	文本型		0
i	整数型
原表项数	整数型
列组	文本型		0
n	整数型

' 2G以上需要置更大的可用内存
' 局_字节集.置可用内存 (, )
' 文本.置可用内存 (, )
超级列表框.禁止重画 ()
超级列表框.可视 ＝ 假  ' 可视的话会耽误更多时间
如果真 (是否为空 (列隔符))
列隔符 ＝ #表格空格符

判断 (文件路径 ≠ “”)  ' 路径优先
文本.从文件读 (文件路径)
文本.置文本 (总文本)

行组 ＝ 文本.分割文本 ( #换行符, )
文本.清除文本 ()
如果真 (保留原有数据 ＝ 真)
' 原表项数 ＝ 超级列表框.取表项数 ()
字节集.添加 (超级列表框.表项)

计次循环首 (取数组成员数 (行组), i)
列组 ＝ 分割文本 (行组 [i], 列隔符, )
计次循环首 (取数组成员数 (列组), n)
判断 (n ＝ 1)
' 字节集 ＝ { 0 } ＋ 到字节集 (图片索引) ＋ 到字节集 (状态图片) ＋ 到字节集 (缩进数目) ＋ 到字节集 (项目数值) ＋ 到字节集 (表项标题) ＋ { 0, 0 }  ' 图片索引默认为-1 ' 状态图片默认为-1
字节集.添加 ({ 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (列组 [n]), { 0, 0 })
字节集.添加 ({ 1, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (列组 [n]), { 0, 0 })

计次循环尾 ()
计次循环尾 ()
超级列表框.表项 ＝ 字节集.取字节集 (, )
超级列表框.允许重画 ()
字节集.清除字节集 ()
超级列表框.可视 ＝ 真

子程序名	返回值类型	公开	备 注
超级列表框_快速导出文本			之前不能有删除操作 超列删除只是标记删除
参数名	类 型	参考	可空	数组	备 注
超级列表框	超级列表框
列隔符	文本型
保存路径	文本型
保存方式	逻辑型				真保存字节集，假保存文本格式

变量名	类 型	静态	数组	备 注
数据	快速字节集对象
bin	字节集
arr	字节集		0
i	整数型
数据2	快速字节集对象
w	整数型
tmp	字节集

数据.添加 (超级列表框.表项)
数据.替换子字节集 ({ 0, 0, 1, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (列隔符), , -1)
数据.替换子字节集 ({ 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 ( #换行符 ), , -1)
bin ＝ 数据.取字节集 (18, 数据.取长度 () － 19)
判断 (保存方式 ＝ 真)
写到文件 (保存路径, bin)

数据.置字节集 (bin)
arr ＝ 数据.分割字节集 (到字节集 ( #换行符 ), )
计次循环首 (取数组成员数 (arr), i)
w ＝ 寻找字节集 (arr [i], 到字节集 (列隔符), )
tmp ＝ 取字节集右边 (arr [i], 取字节集长度 (arr [i]) － 取文本长度 (列隔符) － w ＋ 1)
数据2.添加 (tmp, 到字节集 ( #换行符 ))
计次循环尾 ()
写到文件 (保存路径, 数据2.取字节集 (, ))

i支持库列表	支持库注释
commobj	通用对象支持库
iext	扩展界面支持库一

.版本 2<br /> .支持库 commobj<br /> .支持库 iext<br /> <br /> .子程序 超级列表框_快速导入数据, , 公开<br /> .参数 超级列表框, 超级列表框<br /> .参数 文件路径, 文本型, 可空, 路径优先<br /> .参数 总文本, 文本型, 可空, 路径为空时导入文本<br /> .参数 列隔符, 文本型, 可空, 默认#表格空格符<br /> .参数 保留原有数据, 逻辑型, 可空, 默认不保留  如果保留 必须是没经过删除的数据 超列的删除是标记删除<br /> .局部变量 字节集, 快速字节集对象<br /> .局部变量 文本, 快速文本对象<br /> .局部变量 行组, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 原表项数, 整数型<br /> .局部变量 列组, 文本型, , "0"<br /> .局部变量 n, 整数型<br /> <br /> <br /> ' 2G以上需要置更大的可用内存<br /> ' 局_字节集.置可用内存 (, )<br /> ' 文本.置可用内存 (, )<br /> 超级列表框.禁止重画 ()<br /> 超级列表框.可视 ＝ 假  ' 可视的话会耽误更多时间<br /> .如果真 (是否为空 (列隔符))<br />     列隔符 ＝ #表格空格符<br /> .如果真结束<br /> <br /> .判断开始 (文件路径 ≠ “”)  ' 路径优先<br />     文本.从文件读 (文件路径)<br /> .默认<br />     文本.置文本 (总文本)<br /> .判断结束<br /> <br /> 行组 ＝ 文本.分割文本 (#换行符, )<br /> 文本.清除文本 ()<br /> <br /> .如果真 (保留原有数据 ＝ 真)<br />     ' 原表项数 ＝ 超级列表框.取表项数 ()<br />     字节集.添加 (超级列表框.表项)<br /> .如果真结束<br /> <br /> .计次循环首 (取数组成员数 (行组), i)<br />     列组 ＝ 分割文本 (行组 <i>, 列隔符, )<br />     .计次循环首 (取数组成员数 (列组), n)<br />         .判断开始 (n ＝ 1)<br />             ' 字节集 ＝ { 0 } ＋ 到字节集 (图片索引) ＋ 到字节集 (状态图片) ＋ 到字节集 (缩进数目) ＋ 到字节集 (项目数值) ＋ 到字节集 (表项标题) ＋ { 0, 0 }  ' 图片索引默认为-1 ' 状态图片默认为-1<br />             字节集.添加 ({ 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (列组 [n]), { 0, 0 })<br />         .默认<br />             字节集.添加 ({ 1, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (列组 [n]), { 0, 0 })<br />         .判断结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> <br /> <br /> 超级列表框.表项 ＝ 字节集.取字节集 (, )<br /> 超级列表框.允许重画 ()<br /> 字节集.清除字节集 ()<br /> 超级列表框.可视 ＝ 真<br /> <br /> <br /> <br /> .子程序 超级列表框_快速导出文本, , 公开, 之前不能有删除操作 超列删除只是标记删除<br /> .参数 超级列表框, 超级列表框<br /> .参数 列隔符, 文本型<br /> .参数 保存路径, 文本型<br /> .参数 保存方式, 逻辑型, , 真保存字节集，假保存文本格式<br /> .局部变量 数据, 快速字节集对象<br /> .局部变量 bin, 字节集<br /> .局部变量 arr, 字节集, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 数据2, 快速字节集对象<br /> .局部变量 w, 整数型<br /> .局部变量 tmp, 字节集<br /> <br /> 数据.添加 (超级列表框.表项)<br /> 数据.替换子字节集 ({ 0, 0, 1, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (列隔符), , -1)<br /> 数据.替换子字节集 ({ 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0 }, 到字节集 (#换行符), , -1)<br /> bin ＝ 数据.取字节集 (18, 数据.取长度 () － 19)<br /> .判断开始 (保存方式 ＝ 真)<br />     写到文件 (保存路径, bin)<br /> <br /> .默认<br />     数据.置字节集 (bin)<br />     arr ＝ 数据.分割字节集 (到字节集 (#换行符), )<br />     .计次循环首 (取数组成员数 (arr), i)<br />         w ＝ 寻找字节集 (arr <i>, 到字节集 (列隔符), )<br />         tmp ＝ 取字节集右边 (arr <i>, 取字节集长度 (arr <i>) － 取文本长度 (列隔符) － w ＋ 1)<br />         数据2.添加 (tmp, 到字节集 (#换行符))<br />     .计次循环尾 ()<br />     写到文件 (保存路径, 数据2.取字节集 (, ))<br /> .判断结束

补充内容 (2025-3-22 20:54):
.版本 2

超级列表框_快速导入数据 (超级列表框1, 文件路径, , “ - ”, 假)
超级列表框_快速导出文本 (超级列表框1, “ - ”, 文件路径, 假)

浮梦

算法艺术家 发表于 2025-3-22 20:47
[e=3].版本 2
.支持库 commobj
.支持库 iext

正在编译现行程序
正在检查重复名称...
正在预处理现行程序
错误(11): 逗号（参数分隔符）处于错误位置。
编译现行易程序失败或被中止!


补充内容 (2025-3-22 20:58):
复制进去运行就报错

算法艺术家

浮梦 发表于 2025-3-22 20:57
正在编译现行程序
正在检查重复名称...
正在预处理现行程序

开始发的那一对命令肯定没问题，刚试了

补充内容 (2025-3-22 21:12):
快速导出 之前写的好像有点问题 等我改改

aipca

数据如果太大了不建议用这样的文本来处理。

是可可吖

超级列表框常用
https://bbs.125.la/forum.php?mod=viewthread&tid=14782955
(出处: 精易论坛)

浮梦

aipca 发表于 2025-3-22 21:11
数据如果太大了不建议用这样的文本来处理。

数据字多了有换行符     导入就会错乱