求助，易源码转视窗 - 递归火山软件开发平台

<火山程序类型 = "通常" 版本 = 1 />
类取拼音001 <公开折叠>
{
方法对比测试 <公开类型 = 文本型>
参数文本内容 <类型 = 文本型 @默认值 = "嘻嘻哈哈7799闇龍..?">
{
变量 xj <类型 = 计算耗时类>
变量 t <类型 = 文本型>
变量 tt <类型 = 文本型>
xj.重新计时 ()
t = 取拼音_快速0 (文本内容, 假, "|")
调试输出 (t)
tt = tt + " (哈希表首次:" + xj.取耗时文本 (真, -1, , , )
计次循环 (100000)
{
取拼音_快速0 (文本内容, 假, "|")
}
tt = tt + ">10W次:" + xj.取耗时文本 (真, -1, , , ) + ")"
// 本对象.标题 = tt
调试输出 (tt)
xj.重新计时 ()
t = 取拼音_快速1 (文本内容, 假, "|")
调试输出 (t)
tt = tt + " (无序哈希表首次:" + xj.取耗时文本 (真, -1, , , )
计次循环 (100000) // 60毫秒
{
取拼音_快速1 (文本内容, 假, "|")
}
tt = tt + ">>10W次:" + xj.取耗时文本 (真, -1, , , ) + ")"
// 本对象.标题 = tt
调试输出 (tt)
xj.重新计时 ()
t = 取拼音_快速2 (文本内容, 假, "|")
调试输出 (t)
tt = tt + " (对象数组首次:" + xj.取耗时文本 (真, -1, , , )
计次循环 (100000) // 60毫秒
{
取拼音_快速2 (文本内容, 假, "|")
}
tt = tt + ">>>10W次:" + xj.取耗时文本 (真, -1, , , ) + ")"
// 本对象.标题 = tt
调试输出 (tt)
返回 (tt)
}
常量拼音字典 <类型 = 视窗文件资源值 = "拼音字典1.txt">
变量全局_拼音二维数组_初始化0 <类型 = 逻辑型值 = 假注释 = "哈希表">
变量全局_拼音二维数组_初始化1 <类型 = 逻辑型值 = 假注释 = "无序哈希表">
变量全局_拼音二维数组_初始化2 <类型 = 逻辑型值 = 假注释 = "对象数组">
变量全局_拼音二维数组0 <类型 = 字符到文本哈希表注释 = "哈希表">
变量全局_拼音二维数组1 <类型 = 字符到文本无序哈希表注释 = "无序哈希表">
变量全局_拼音二维数组2 <类型 = 字符与拼音_数组注释 = "对象数组">
方法取拼音_数组_初始化0 <注释 = "哈希表">
{
变量拼音_数组 <类型 = 文本数组类>
变量首字符 <类型 = 字符>
变量文本内容 <类型 = 文本型>
变量 j <类型 = 字节集类>
全局_拼音二维数组0.清空 ()
全局_拼音二维数组_初始化0 = 真
如果 (文件资源到字节集 (拼音字典, j) == 真)
{
文本内容 = 多字节到文本 (j)
如果 (分割文本 (文本内容, ",", 拼音_数组, 真, 真) > 0)
{
拼音_数组.枚举循环 ()
{
文本内容 = 拼音_数组.取枚举值 ()
如果 (取文本长度 (文本内容) > 1)
{
首字符 = 取字符 (文本内容, 0)
全局_拼音二维数组0.插入 (首字符, 取文本右边 (文本内容, 取文本长度 (文本内容) - 1))
}
}
}
}
}
方法取拼音_快速0 <公开类型 = 文本型注释 = "哈希表">
参数文本 <类型 = 文本型注释 = "欲取拼音的文本">
参数保留非汉字 <类型 = 逻辑型注释 = "默认假，如果某个字符在字典中不存在，则不输出该字符；如果为真则保留。" @默认值 = 假>
参数分隔符 <类型 = 文本型注释 = "默认用空格分割" @默认值 = " ">
{
变量 i <类型 = 整数注释 = "下标">
变量当前字符 <类型 = 字符>
变量返回值 <类型 = 文本型>
如果 (全局_拼音二维数组_初始化0 == 假)
{
取拼音_数组_初始化0 ()
}
如果 (文本是否为空 (分隔符) == 真)
{
分隔符 = " "
}
返回值 = ""
i = 取文本长度 (文本)
计次循环 (i)
{
当前字符 = 取字符 (文本, 取循环索引 ())
如果 (全局_拼音二维数组0.是否存在 (当前字符) == 真)
{
加入文本 (返回值, 全局_拼音二维数组0.取值 (当前字符))
加入文本 (返回值, 分隔符)
}
否则 (当前字符 == 13 || 当前字符 == 10)
{
加入字符 (返回值, 当前字符)
}
否则 (保留非汉字 == 真)
{
加入字符 (返回值, 当前字符)
加入文本 (返回值, 分隔符)
}
否则
{
// 加入文本 (返回值, 分隔符)
}
}
删自身尾空 (返回值)
返回 (返回值)
}
方法取拼音_数组_初始化1 <注释 = "无序哈希表" 折叠>
{
变量拼音_数组 <类型 = 文本数组类>
变量首字符 <类型 = 字符>
变量文本内容 <类型 = 文本型>
变量 j <类型 = 字节集类>
全局_拼音二维数组1.清空 ()
全局_拼音二维数组_初始化1 = 真
如果 (文件资源到字节集 (拼音字典, j) == 真)
{
文本内容 = 多字节到文本 (j)
如果 (分割文本 (文本内容, ",", 拼音_数组, 真, 真) > 0)
{
拼音_数组.枚举循环 ()
{
文本内容 = 拼音_数组.取枚举值 ()
如果 (取文本长度 (文本内容) > 1)
{
首字符 = 取字符 (文本内容, 0)
全局_拼音二维数组1.插入 (首字符, 取文本右边 (文本内容, 取文本长度 (文本内容) - 1))
}
}
}
}
}
方法取拼音_快速1 <公开类型 = 文本型注释 = "无序哈希表">
参数文本 <类型 = 文本型注释 = "欲取拼音的文本" 折叠>
参数保留非汉字 <类型 = 逻辑型注释 = "默认假，如果某个字符在字典中不存在，则不输出该字符；如果为真则保留。" @默认值 = 假>
参数分隔符 <类型 = 文本型注释 = "默认用空格分割" @默认值 = " ">
{
变量 i <类型 = 整数注释 = "下标">
变量当前字符 <类型 = 字符>
变量返回值 <类型 = 文本型>
如果 (全局_拼音二维数组_初始化1 == 假)
{
取拼音_数组_初始化1 ()
}
如果 (文本是否为空 (分隔符) == 真)
{
分隔符 = " "
}
返回值 = ""
i = 取文本长度 (文本)
计次循环 (i)
{
当前字符 = 取字符 (文本, 取循环索引 ())
如果 (全局_拼音二维数组1.是否存在 (当前字符) == 真)
{
加入文本 (返回值, 全局_拼音二维数组1.取值 (当前字符))
加入文本 (返回值, 分隔符)
}
否则 (当前字符 == 13 || 当前字符 == 10)
{
加入字符 (返回值, 当前字符)
}
否则 (保留非汉字 == 真)
{
加入字符 (返回值, 当前字符)
加入文本 (返回值, 分隔符)
}
否则
{
// 加入文本 (返回值, 分隔符)
}
}
删自身尾空 (返回值)
返回 (返回值)
}
方法取拼音_数组_初始化2 <注释 = "对象数组" 折叠>
{
变量拼音_数组 <类型 = 文本数组类>
变量首字符 <类型 = 字符>
变量文本内容 <类型 = 文本型>
变量 j <类型 = 字节集类>
// 全局_拼音二维数组.清空 ()
全局_拼音二维数组2.删除所有成员 ()
全局_拼音二维数组_初始化2 = 真
如果 (文件资源到字节集 (拼音字典, j) == 真)
{
全局_拼音二维数组2.批量加入新成员 (字符与拼音, 65536)
// 计次循环 (65536)
{
// 首字符 = (字符)取循环索引 ()
// 文本内容 = ""
// 文本内容 = 加入字符 (首字符)
// 全局_拼音二维数组.加入成员 (文本内容)
}
文本内容 = 多字节到文本 (j)
如果 (分割文本 (文本内容, ",", 拼音_数组, 真, 真) > 0)
{
拼音_数组.枚举循环 ()
{
文本内容 = 拼音_数组.取枚举值 ()
如果 (取文本长度 (文本内容) > 1)
{
首字符 = 取字符 (文本内容, 0)
// 全局_拼音二维数组.插入 (首字符, 取文本右边 (文本内容, 取文本长度 (文本内容) - 1))
全局_拼音二维数组2.取成员 ((整数)首字符).是否有效 = 真
全局_拼音二维数组2.取成员 ((整数)首字符).拼音文本 = 取文本右边 (文本内容, 取文本长度 (文本内容) - 1)
}
}
}
}
}
方法取拼音_快速2 <公开类型 = 文本型注释 = "对象数组" 折叠>
参数文本 <类型 = 文本型注释 = "欲取拼音的文本">
参数保留非汉字 <类型 = 逻辑型注释 = "默认假，如果某个字符在字典中不存在，则不输出该字符；如果为真则保留。" @默认值 = 假>
参数分隔符 <类型 = 文本型注释 = "默认用空格分割" @默认值 = " ">
{
变量 i <类型 = 整数注释 = "下标">
变量当前字符 <类型 = 字符>
变量返回值 <类型 = 文本型>
如果 (全局_拼音二维数组_初始化2 == 假)
{
取拼音_数组_初始化2 ()
}
如果 (文本是否为空 (分隔符) == 真)
{
分隔符 = " "
}
返回值 = ""
i = 取文本长度 (文本)
计次循环 (i)
{
当前字符 = 取字符 (文本, 取循环索引 ())
如果 (全局_拼音二维数组2.取成员 ((整数)当前字符).是否有效 == 真) // 全局_拼音二维数组.是否存在 (当前字符) == 真)
{
加入文本 (返回值, 全局_拼音二维数组2.取成员 ((整数)当前字符).拼音文本)
// 加入文本 (返回值, 全局_拼音二维数组.取值 (当前字符))
加入文本 (返回值, 分隔符)
}
否则 (当前字符 == 13 || 当前字符 == 10)
{
加入字符 (返回值, 当前字符)
}
否则 (保留非汉字 == 真)
{
加入字符 (返回值, 当前字符)
加入文本 (返回值, 分隔符)
}
否则
{
// 加入文本 (返回值, 分隔符)
}
}
删自身尾空 (返回值)
返回 (返回值)
}
}
类字符到文本无序哈希表 <公开基础类 = 基本无序哈希表模板类 @模板实现类 = "字符,文本型">
类字符到文本哈希表 <公开基础类 = 通用哈希表模板类 @模板实现类 = "字符,文本型">
类字符与拼音_数组 <基础类 = 对象数组模板类 @模板实现类 = "字符与拼音">
类字符与拼音 <折叠>
{
变量是否有效 <公开类型 = 逻辑型值 = 假>
变量字符值 <公开类型 = 字符值 = 0>
变量拼音文本 <公开类型 = 文本型值 = "">
}

复制代码