求助，数组元素有相同的前缀项，并各自输出，

filippo009

加入如下，我有几个数组，这里就举例两个，里面有元素内容如下：
数组1： a#0304#1,b#0304#2,c#0304#1,d#0304#1
数组2 ：d#0305#1,a#0305#2,e#0305#1,f#0305#1

希望找出相同的，并输出#后面的内容:
输出 a.txt => 0304#1
                0305#1
     b.txt=>  0304#2
     c.txt=> 0304#1
     d.txt => 0304#1
              0305#1
     e.txt => 0305#1
     f.txt => 0305#1


请教大神，这种要怎么处理呢，谢谢

zainex

这代码就是输出到多个文件里：

Ruang

你这数量好像挺大的

zainex

用 节点 实现，它会在桌面创建一个txt文件夹，文件会保存到里面：

  

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

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

变量名	类 型	静态	数组	备 注
文本	文本型
数组	文本型		0
正则	正则表达式
数	整数型
搜索结果	搜索结果
成员	文本型
节点	节点
名称	文本型
内容	文本型
临时	文本型
属性名	文本型		0
目录	文本型

文本 ＝ 文本 ＋ “a#0304#1 b#0304#2 c#0304#1 d#0304#1 ”
文本 ＝ 文本 ＋ “d#0305#1 a#0305#2 e#0305#1 f#0305#1 ”
数组 ＝ 分割文本 (文本, “ ”, )
调试输出 (数组)
正则.创建 (“([^#]+).(.+)”, )
计次循环首 (取数组成员数 (数组), 数)
成员 ＝ 数组 [数]
搜索结果 ＝ 正则.搜索 (成员, 1, )
名称 ＝ 搜索结果.取子匹配文本 (成员, 1, )
内容 ＝ 搜索结果.取子匹配文本 (成员, 2, )
如果真 (节点.加入属性 (名称, 内容) ＝ 假)
节点.取文本值 (名称, 临时)
临时 ＝ 临时 ＋ #换行符 ＋ 内容
节点.修改属性 (名称, 临时)

计次循环尾 ()
节点.取全部属性名 (属性名)
目录 ＝ 取特定目录 ( #系统桌面 ) ＋ “\txt”
创建目录 (目录)
计次循环首 (取数组成员数 (属性名), 数)
名称 ＝ 属性名 [数]
节点.取文本值 (名称, 内容)
写到文件 (目录 ＋ “\” ＋ 名称 ＋ “.txt”, 到字节集 (内容))
计次循环尾 ()

i支持库列表	支持库注释
RegEx	正则表达式支持库
EDataStructure	数据结构支持库
spec	特殊功能支持库
shell	操作系统界面功能支持库

.版本 2<br /> .支持库 RegEx<br /> .支持库 EDataStructure<br /> .支持库 spec<br /> .支持库 shell<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 文本, 文本型<br /> .局部变量 数组, 文本型, , "0"<br /> .局部变量 正则, 正则表达式<br /> .局部变量 数, 整数型<br /> .局部变量 搜索结果, 搜索结果<br /> .局部变量 成员, 文本型<br /> .局部变量 节点, 节点<br /> .局部变量 名称, 文本型<br /> .局部变量 内容, 文本型<br /> .局部变量 临时, 文本型<br /> .局部变量 属性名, 文本型, , "0"<br /> .局部变量 目录, 文本型<br /> <br /> 文本 ＝ 文本 ＋ “a#0304#1 b#0304#2 c#0304#1 d#0304#1 ”<br /> 文本 ＝ 文本 ＋ “d#0305#1 a#0305#2 e#0305#1 f#0305#1 ”<br /> 数组 ＝ 分割文本 (文本, “ ”, )<br /> 调试输出 (数组)<br /> 正则.创建 (“([^#]+).(.+)”, )<br /> .计次循环首 (取数组成员数 (数组), 数)<br />     成员 ＝ 数组 [数]<br />     搜索结果 ＝ 正则.搜索 (成员, 1, )<br />     名称 ＝ 搜索结果.取子匹配文本 (成员, 1, )<br />     内容 ＝ 搜索结果.取子匹配文本 (成员, 2, )<br />     .如果真 (节点.加入属性 (名称, 内容) ＝ 假)<br />         节点.取文本值 (名称, 临时)<br />         临时 ＝ 临时 ＋ #换行符 ＋ 内容<br />         节点.修改属性 (名称, 临时)<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 节点.取全部属性名 (属性名)<br /> 目录 ＝ 取特定目录 (#系统桌面) ＋ “\txt”<br /> 创建目录 (目录)<br /> .计次循环首 (取数组成员数 (属性名), 数)<br />     名称 ＝ 属性名 [数]<br />     节点.取文本值 (名称, 内容)<br />     写到文件 (目录 ＋ “\” ＋ 名称 ＋ “.txt”, 到字节集 (内容))<br /> .计次循环尾 ()

filippo009

zainex 发表于 2025-5-4 18:35
用 节点 实现，它会在桌面创建一个txt文件夹，文件会保存到里面：
[e=1].版本 2
.支持库 RegEx

谢谢你，看正则我一直很晕，这是输出到一个.txt ，是要各自输出到txt， 有多少.txt,,,,,,比如a.txt b.txt。。。

Ruang

  

子程序名	返回值类型	公开	备 注
功能_数据归类
参数名	类 型	参考	可空	数组	备 注
参数_一	文本型
参数_二	文本型

变量名	类 型	静态	数组	备 注
总数组	文本型		0
计次1	整数型
计次2	整数型
前缀文本	文本型
后缀文本	文本型
节点	节点
节点名称	文本型		0
临时	文本型		0
是否存在	逻辑型
待加入文本	文本型

计次循环首 (取数组成员数 (参数_一), 计次1)  ' 合并到总数组
加入成员 (总数组, 参数_一 [计次1])
计次循环尾 ()
计次循环首 (取数组成员数 (参数_二), 计次1)  ' 合并到总数组
加入成员 (总数组, 参数_二 [计次1])
计次循环尾 ()
计次循环首 (取数组成员数 (总数组), 计次1)  ' 开始分类
前缀文本 ＝ 取文本左边 (总数组 [计次1], 寻找文本 (总数组 [计次1], “#”, , 假) － 1)
后缀文本 ＝ 子文本替换 (总数组 [计次1], 取文本左边 (总数组 [计次1], 寻找文本 (总数组 [计次1], “#”, , 假) － 1) ＋ “#”, “”, , , 真)
节点.取全部属性名 (临时)
计次循环首 (取数组成员数 (临时), 计次2)
是否存在 ＝ 假
如果真 (临时 [计次2] ＝ 前缀文本)
是否存在 ＝ 真
跳出循环 ()

计次循环尾 ()
如果 (是否存在 ＝ 假)
节点.加入属性 (前缀文本, 后缀文本)
节点.取文本值 (前缀文本, 待加入文本)
节点.修改属性 (前缀文本, 待加入文本 ＋ “,” ＋ 后缀文本)

计次循环尾 ()
节点.取全部属性名 (节点名称)
计次循环首 (取数组成员数 (节点名称), 计次1)  ' 输出文本
节点.取文本值 (节点名称 [计次1], 待加入文本)
临时 ＝ 分割文本 (待加入文本, “,”, )
计次循环首 (取数组成员数 (临时), 计次2)
如果真 (计次2 ＝ 1)
调试输出 (节点名称 [计次1] ＋ “.txt => ” ＋ 临时 [计次2])
到循环尾 ()
调试输出 (“              ” ＋ 临时 [计次2])
计次循环尾 ()
计次循环尾 ()

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

.版本 2<br /> .支持库 EDataStructure<br /> .支持库 spec<br /> <br /> .子程序 功能_数据归类<br /> .参数 参数_一, 文本型, 数组<br /> .参数 参数_二, 文本型, 数组<br /> .局部变量 总数组, 文本型, , "0"<br /> .局部变量 计次1, 整数型<br /> .局部变量 计次2, 整数型<br /> .局部变量 前缀文本, 文本型<br /> .局部变量 后缀文本, 文本型<br /> .局部变量 节点, 节点<br /> .局部变量 节点名称, 文本型, , "0"<br /> .局部变量 临时, 文本型, , "0"<br /> .局部变量 是否存在, 逻辑型<br /> .局部变量 待加入文本, 文本型<br /> <br /> .计次循环首 (取数组成员数 (参数_一), 计次1)  ' 合并到总数组<br />     加入成员 (总数组, 参数_一 [计次1])<br /> .计次循环尾 ()<br /> .计次循环首 (取数组成员数 (参数_二), 计次1)  ' 合并到总数组<br />     加入成员 (总数组, 参数_二 [计次1])<br /> .计次循环尾 ()<br /> <br /> .计次循环首 (取数组成员数 (总数组), 计次1)  ' 开始分类<br />     前缀文本 ＝ 取文本左边 (总数组 [计次1], 寻找文本 (总数组 [计次1], “#”, , 假) － 1)<br />     后缀文本 ＝ 子文本替换 (总数组 [计次1], 取文本左边 (总数组 [计次1], 寻找文本 (总数组 [计次1], “#”, , 假) － 1) ＋ “#”, “”, , , 真)<br />     节点.取全部属性名 (临时)<br />     .计次循环首 (取数组成员数 (临时), 计次2)<br />         是否存在 ＝ 假<br />         .如果真 (临时 [计次2] ＝ 前缀文本)<br />             是否存在 ＝ 真<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     .如果 (是否存在 ＝ 假)<br />         节点.加入属性 (前缀文本, 后缀文本)<br />     .否则<br />         节点.取文本值 (前缀文本, 待加入文本)<br />         节点.修改属性 (前缀文本, 待加入文本 ＋ “,” ＋ 后缀文本)<br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> 节点.取全部属性名 (节点名称)<br /> <br /> .计次循环首 (取数组成员数 (节点名称), 计次1)  ' 输出文本<br />     节点.取文本值 (节点名称 [计次1], 待加入文本)<br />     临时 ＝ 分割文本 (待加入文本, “,”, )<br />     .计次循环首 (取数组成员数 (临时), 计次2)<br />         .如果真 (计次2 ＝ 1)<br />             调试输出 (节点名称 [计次1] ＋ “.txt => ” ＋ 临时 [计次2])<br />             到循环尾 ()<br />         .如果真结束<br />         调试输出 (“              ” ＋ 临时 [计次2])<br />     .计次循环尾 ()<br /> <br /> .计次循环尾 ()

节点方式

Ruang

输出结果图

zainex

如果你是不想用正则，那么可以把上面代码中的：

  

搜索结果 ＝ 正则.搜索 (成员, 1, )
名称 ＝ 搜索结果.取子匹配文本 (成员, 1, )
内容 ＝ 搜索结果.取子匹配文本 (成员, 2, )

搜索结果 ＝ 正则.搜索 (成员, 1, )<br /> 名称 ＝ 搜索结果.取子匹配文本 (成员, 1, )<br /> 内容 ＝ 搜索结果.取子匹配文本 (成员, 2, )

给换成：

  

变量名	类 型	静态	数组	备 注
下标	整数型

下标 ＝ 寻找文本 (成员, “#”, , 假)
名称 ＝ 取文本中间 (成员, 1, 下标 － 1)
内容 ＝ 取文本中间 (成员, 下标 ＋ 1, 取文本长度 (成员))

.局部变量 下标, 整数型<br /> 下标 ＝ 寻找文本 (成员, “#”, , 假)<br /> 名称 ＝ 取文本中间 (成员, 1, 下标 － 1)<br /> 内容 ＝ 取文本中间 (成员, 下标 ＋ 1, 取文本长度 (成员))

这两段代码得到的结果是一样的。

你的猫

  

子程序名	返回值类型	公开	备 注
比较数组并输出

变量名	类 型	静态	数组	备 注
数组1	文本型		0
数组2	文本型		0
i	整数型
j	整数型
元素1	文本型
元素2	文本型
前缀1	文本型
前缀2	文本型
内容1	文本型
内容2	文本型
文件号	整数型
文件名	文本型
已处理前缀	文本型		0
k	整数型
是否已处理	逻辑型

' 初始化数组
数组1 ＝ 分割文本 (“a#0304#1,b#0304#2,c#0304#1,d#0304#1”, “,”, )
数组2 ＝ 分割文本 (“d#0305#1,a#0305#2,e#0305#1,f#0305#1”, “,”, )
' 处理数组1
计次循环首 (取数组成员数 (数组1), i)
元素1 ＝ 数组1 [i]
前缀1 ＝ 取文本左边 (元素1, 寻找文本 (元素1, “#”, , 假) － 1)
内容1 ＝ 取文本右边 (元素1, 取文本长度 (元素1) － 寻找文本 (元素1, “#”, , 假))
' 检查是否已经处理过这个前缀
是否已处理 ＝ 假
计次循环首 (取数组成员数 (已处理前缀), k)
如果真 (已处理前缀 [k] ＝ 前缀1)
是否已处理 ＝ 真
跳出循环 ()

计次循环尾 ()
如果真 (是否已处理 ＝ 假)
' 添加到已处理列表
加入成员 (已处理前缀, 前缀1)
' 创建对应文件
文件名 ＝ 前缀1 ＋ “.txt”
文件号 ＝ 打开文件 (文件名, #重写, )
' 写入当前内容
写文本行 (文件号, 内容1)
' 检查数组2中是否有相同前缀
计次循环首 (取数组成员数 (数组2), j)
元素2 ＝ 数组2 [j]
前缀2 ＝ 取文本左边 (元素2, 寻找文本 (元素2, “#”, , 假) － 1)
内容2 ＝ 取文本右边 (元素2, 取文本长度 (元素2) － 寻找文本 (元素2, “#”, , 假))
如果真 (前缀2 ＝ 前缀1)
写文本行 (文件号, 内容2)

计次循环尾 ()
关闭文件 (文件号)

计次循环尾 ()
' 处理数组2中未被处理的前缀
计次循环首 (取数组成员数 (数组2), i)
元素2 ＝ 数组2 [i]
前缀2 ＝ 取文本左边 (元素2, 寻找文本 (元素2, “#”, , 假) － 1)
内容2 ＝ 取文本右边 (元素2, 取文本长度 (元素2) － 寻找文本 (元素2, “#”, , 假))
' 检查是否已经处理过这个前缀
是否已处理 ＝ 假
计次循环首 (取数组成员数 (已处理前缀), k)
如果真 (已处理前缀 [k] ＝ 前缀2)
是否已处理 ＝ 真
跳出循环 ()

计次循环尾 ()
如果真 (是否已处理 ＝ 假)
' 添加到已处理列表
加入成员 (已处理前缀, 前缀2)
' 创建对应文件
文件名 ＝ 前缀2 ＋ “.txt”
文件号 ＝ 打开文件 (文件名, #重写, )
' 写入当前内容
写文本行 (文件号, 内容2)
关闭文件 (文件号)

计次循环尾 ()

.版本 2<br /> <br /> .子程序 比较数组并输出<br /> .局部变量 数组1, 文本型, , "0"<br /> .局部变量 数组2, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> .局部变量 元素1, 文本型<br /> .局部变量 元素2, 文本型<br /> .局部变量 前缀1, 文本型<br /> .局部变量 前缀2, 文本型<br /> .局部变量 内容1, 文本型<br /> .局部变量 内容2, 文本型<br /> .局部变量 文件号, 整数型<br /> .局部变量 文件名, 文本型<br /> .局部变量 已处理前缀, 文本型, , "0"<br /> .局部变量 k, 整数型<br /> .局部变量 是否已处理, 逻辑型<br /> <br /> ' 初始化数组<br /> 数组1 ＝ 分割文本 (“a#0304#1,b#0304#2,c#0304#1,d#0304#1”, “,”, )<br /> 数组2 ＝ 分割文本 (“d#0305#1,a#0305#2,e#0305#1,f#0305#1”, “,”, )<br /> <br /> ' 处理数组1<br /> .计次循环首 (取数组成员数 (数组1), i)<br />     元素1 ＝ 数组1 <i><br />     前缀1 ＝ 取文本左边 (元素1, 寻找文本 (元素1, “#”, , 假) － 1)<br />     内容1 ＝ 取文本右边 (元素1, 取文本长度 (元素1) － 寻找文本 (元素1, “#”, , 假))<br /> <br />     ' 检查是否已经处理过这个前缀<br />     是否已处理 ＝ 假<br />     .计次循环首 (取数组成员数 (已处理前缀), k)<br />         .如果真 (已处理前缀 [k] ＝ 前缀1)<br />             是否已处理 ＝ 真<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> <br />     .如果真 (是否已处理 ＝ 假)<br />         ' 添加到已处理列表<br />         加入成员 (已处理前缀, 前缀1)<br /> <br />         ' 创建对应文件<br />         文件名 ＝ 前缀1 ＋ “.txt”<br />         文件号 ＝ 打开文件 (文件名, #重写, )<br /> <br />         ' 写入当前内容<br />         写文本行 (文件号, 内容1)<br /> <br />         ' 检查数组2中是否有相同前缀<br />         .计次循环首 (取数组成员数 (数组2), j)<br />             元素2 ＝ 数组2 [j]<br />             前缀2 ＝ 取文本左边 (元素2, 寻找文本 (元素2, “#”, , 假) － 1)<br />             内容2 ＝ 取文本右边 (元素2, 取文本长度 (元素2) － 寻找文本 (元素2, “#”, , 假))<br /> <br />             .如果真 (前缀2 ＝ 前缀1)<br />                 写文本行 (文件号, 内容2)<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br /> <br />         关闭文件 (文件号)<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> ' 处理数组2中未被处理的前缀<br /> .计次循环首 (取数组成员数 (数组2), i)<br />     元素2 ＝ 数组2 <i><br />     前缀2 ＝ 取文本左边 (元素2, 寻找文本 (元素2, “#”, , 假) － 1)<br />     内容2 ＝ 取文本右边 (元素2, 取文本长度 (元素2) － 寻找文本 (元素2, “#”, , 假))<br /> <br />     ' 检查是否已经处理过这个前缀<br />     是否已处理 ＝ 假<br />     .计次循环首 (取数组成员数 (已处理前缀), k)<br />         .如果真 (已处理前缀 [k] ＝ 前缀2)<br />             是否已处理 ＝ 真<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> <br />     .如果真 (是否已处理 ＝ 假)<br />         ' 添加到已处理列表<br />         加入成员 (已处理前缀, 前缀2)<br /> <br />         ' 创建对应文件<br />         文件名 ＝ 前缀2 ＋ “.txt”<br />         文件号 ＝ 打开文件 (文件名, #重写, )<br /> <br />         ' 写入当前内容<br />         写文本行 (文件号, 内容2)<br /> <br />         关闭文件 (文件号)<br />     .如果真结束<br /> <br /> .计次循环尾 ()