超厉害纯算法的字符串文本计算！！！

精意源码

在易语言中，若想计算字符串文本内容，例如“((1+32)*12+6/3*)123456-1234”这样复杂的内容
在 JavaScript 中，可以通过 eval() 函数来计算表达式的值。eval() 会解析并执行一个字符串作为 JavaScript 代码。

[JavaScript] 纯文本查看 复制代码

let expression = "(1+32)*12+6/3*123456-1234";
let result = eval(expression);
console.log(result);

在易语言里，也可以使用精易模块的脚本组件

  

变量名	类 型	静态	数组	备 注
类_脚本组件	类_脚本组件

调试输出 (类_脚本组件.计算表达式 (“(2+5)*5+6/2*10086”))

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

.版本 2<br /> .支持库 spec<br /> <br /> .局部变量 类_脚本组件, 类_脚本组件<br /> <br /> 调试输出 (类_脚本组件.计算表达式 (“(2+5)*5+6/2*10086”))

一天突发奇想想做一个纯算法的的计算表达式源码，才发现超级复杂！！！
1.首先我们先对“((1+32)*12+6/3)*123456-1234”进行分析，计算顺序是 括号 →乘除 →加减 ，看起来很简单是吧，可是如何计算(1+32)的答案，再替换到((1+32)*12+6/3)，再计算之后的值，需要层层解剖，下面是参考代码

  

[e=1].版本 2

变量名	类 型	静态	数组	备 注
类_脚本组件	类_脚本组件

调试输出 (类_脚本组件.[e=0].版本 2

子程序名	返回值类型	公开	备 注
计算表达式	小数型
参数名	类 型	参考	可空	数组	备 注
文本	计算表达式

变量名	类 型	静态	数组	备 注
text	文本型
子_text	文本型
A	整数型
B	整数型
I	整数型
元素	文本型		0
子项式	文本型
数组C	文本型		0
项式发布数量	整数型
项式发布符号	文本型		0
R	整数型
总项式数组	文本型		0
总项式	文本型
D	整数型
W	整数型
结果	文本型
数组_随机数	文本型		0
V	整数型
是否加括号	逻辑型
text_F	文本型		0
F	整数型
text_F_数组	文本型		0

' 调试输出 (基础算式0 (“1+1.5+5/51*0”))
' 结束 ()
' “(4*3)+(3*4)”
' text ＝ “1/(（4*3+4*3)+2)”
text ＝ “2+5*5+6/2*10086”
' 基本格式化============
text ＝ 文本_子文本替换_批量单个对应替换 (text, { “（”, “）”, “×”, “x”, “X”, “÷”, “＋”, “－”, “ ” }, { “(”, “)”, “*”, “*”, “*”, “/”, “+”, “-”, “” })
是否加括号 ＝ 真
如果真 (取文本左边 (text, 1) ＝ “-”)
text ＝ “0” ＋ text
如果真 (文本_寻找文本_分割 (text, “()”, , ) ＝ -1)
text ＝ “(” ＋ text ＋ “)”
文本_逐字分割_汇编 (text, text_F)
计次循环首 (取数组成员数 (text_F), F)
如果真 (text_F [F] ＝ “(”)
是否加括号 ＝ 假
如果真 (text_F [F] ＝ “)”)
是否加括号 ＝ 真
到循环尾 ()
如果 (是否加括号 ＝ 真)
如果 (内部_是否为符号 (text_F [F]) ＝ 假)
加入成员 (text_F_数组, “(”)
加入成员 (text_F_数组, text_F [F])
加入成员 (text_F_数组, “)”)
加入成员 (text_F_数组, text_F [F])

加入成员 (text_F_数组, text_F [F])

计次循环尾 ()
加入成员 (text_F_数组, “)”)
text ＝ “”
计次循环首 (取数组成员数 (text_F_数组), R)
text ＝ text ＋ text_F_数组 [R]
计次循环尾 ()
项式发布数量 ＝ 文本_取中间_批量 (text, “(”, “)”, 数组C, , , , , )
' 子_text ＝ 文本_子文本替换_批量_多换一_自动分割 (子_text, “1234567890”, “”)
' 寻找文本 (, , , 假)
文本_取中间_批量 (text, “)”, “(”, 项式发布符号, , , , , )
如果真 (项式发布数量 － 取数组成员数 (项式发布符号) ≠ 1)
' 调试输出 (“出错了！”)
' 返回 ()
计次循环首 (项式发布数量, R)
如果真 (取数组成员数 (项式发布符号) ≠ 0)
text ＝ 数组C [R]
文本_取枚举内层元素 (text, “(”, “)”, 元素)
判断循环首 (真)
I ＝ I ＋ 1
子项式 ＝ 元素 [取数组成员数 (元素)]
text ＝ 子文本替换 (text, “(” ＋ 子项式 ＋ “)”, 基础算式 (子项式), , , 真)
清除数组 (元素)
文本_取枚举内层元素 (text, “(”, “)”, 元素)
如果真 (取数组成员数 (元素) ＝ 1)
子项式 ＝ 元素 [取数组成员数 (元素)]
text ＝ 子文本替换 (text, 子项式, 基础算式 (子项式), , , 真)
跳出循环 ()

判断循环尾 ()
加入成员 (总项式数组, text)
计次循环尾 ()
' 到文本
如果 (取数组成员数 (项式发布符号) ＝ 0)
结果 ＝ text
计次循环首 (取数组成员数 (总项式数组) ＋ 取数组成员数 (项式发布符号), I)
如果 (文本_判断奇偶数 (I) ＝ 0)
D ＝ D ＋ 1 ' 偶数
总项式 ＝ 总项式 ＋ 项式发布符号 [D]
W ＝ W ＋ 1 ' 奇数
总项式 ＝ 总项式 ＋ 总项式数组 [W]

计次循环尾 ()
结果 ＝ 基础算式 (总项式)
返回 (结果)

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

[e=1].版本 2<br /> .支持库 spec<br /> <br /> .局部变量 类_脚本组件, 类_脚本组件<br /> <br /> 调试输出 (类_脚本组件.[e=0].版本 2<br /> <br /> .子程序 计算表达式, 小数型, 公开<br /> .参数 文本, 计算表达式<br /> .局部变量 text, 文本型<br /> .局部变量 子_text, 文本型<br /> .局部变量 A, 整数型<br /> .局部变量 B, 整数型<br /> .局部变量 I, 整数型<br /> .局部变量 元素, 文本型, , "0"<br /> .局部变量 子项式, 文本型<br /> .局部变量 数组C, 文本型, , "0"<br /> .局部变量 项式发布数量, 整数型<br /> .局部变量 项式发布符号, 文本型, , "0"<br /> .局部变量 R, 整数型<br /> .局部变量 总项式数组, 文本型, , "0"<br /> .局部变量 总项式, 文本型<br /> .局部变量 D, 整数型<br /> .局部变量 W, 整数型<br /> .局部变量 结果, 文本型<br /> .局部变量 数组_随机数, 文本型, , "0"<br /> .局部变量 V, 整数型<br /> .局部变量 是否加括号, 逻辑型<br /> .局部变量 text_F, 文本型, , "0"<br /> .局部变量 F, 整数型<br /> .局部变量 text_F_数组, 文本型, , "0"<br /> <br /> ' 调试输出 (基础算式0 (“1+1.5+5/51*0”))<br /> ' 结束 ()<br /> ' “(4*3)+(3*4)”<br /> ' text ＝ “1/(（4*3+4*3)+2)”<br /> text ＝ “2+5*5+6/2*10086”<br /> ' 基本格式化============<br /> text ＝ 文本_子文本替换_批量单个对应替换 (text, { “（”, “）”, “×”, “x”, “X”, “÷”, “＋”, “－”, “ ” }, { “(”, “)”, “*”, “*”, “*”, “/”, “+”, “-”, “” })<br /> 是否加括号 ＝ 真<br /> .如果真 (取文本左边 (text, 1) ＝ “-”)<br /> text ＝ “0” ＋ text<br /> .如果真结束<br /> .如果真 (文本_寻找文本_分割 (text, “()”, , ) ＝ -1)<br /> text ＝ “(” ＋ text ＋ “)”<br /> .如果真结束<br /> 文本_逐字分割_汇编 (text, text_F)<br /> .计次循环首 (取数组成员数 (text_F), F)<br /> .如果真 (text_F [F] ＝ “(”)<br /> 是否加括号 ＝ 假<br /> .如果真结束<br /> .如果真 (text_F [F] ＝ “)”)<br /> 是否加括号 ＝ 真<br /> 到循环尾 ()<br /> .如果真结束<br /> .如果 (是否加括号 ＝ 真)<br /> .如果 (内部_是否为符号 (text_F [F]) ＝ 假)<br /> 加入成员 (text_F_数组, “(”)<br /> 加入成员 (text_F_数组, text_F [F])<br /> .否则<br /> 加入成员 (text_F_数组, “)”)<br /> 加入成员 (text_F_数组, text_F [F])<br /> .如果结束<br /> <br /> .否则<br /> 加入成员 (text_F_数组, text_F [F])<br /> .如果结束<br /> <br /> .计次循环尾 ()<br /> 加入成员 (text_F_数组, “)”)<br /> text ＝ “”<br /> .计次循环首 (取数组成员数 (text_F_数组), R)<br /> text ＝ text ＋ text_F_数组 [R]<br /> .计次循环尾 ()<br /> 项式发布数量 ＝ 文本_取中间_批量 (text, “(”, “)”, 数组C, , , , , )<br /> ' 子_text ＝ 文本_子文本替换_批量_多换一_自动分割 (子_text, “1234567890”, “”)<br /> ' 寻找文本 (, , , 假)<br /> 文本_取中间_批量 (text, “)”, “(”, 项式发布符号, , , , , )<br /> .如果真 (项式发布数量 － 取数组成员数 (项式发布符号) ≠ 1)<br /> ' 调试输出 (“出错了！”)<br /> ' 返回 ()<br /> .如果真结束<br /> .计次循环首 (项式发布数量, R)<br /> .如果真 (取数组成员数 (项式发布符号) ≠ 0)<br /> text ＝ 数组C [R]<br /> .如果真结束<br /> 文本_取枚举内层元素 (text, “(”, “)”, 元素)<br /> .判断循环首 (真)<br /> I ＝ I ＋ 1<br /> 子项式 ＝ 元素 [取数组成员数 (元素)]<br /> text ＝ 子文本替换 (text, “(” ＋ 子项式 ＋ “)”, 基础算式 (子项式), , , 真)<br /> 清除数组 (元素)<br /> 文本_取枚举内层元素 (text, “(”, “)”, 元素)<br /> .如果真 (取数组成员数 (元素) ＝ 1)<br /> 子项式 ＝ 元素 [取数组成员数 (元素)]<br /> text ＝ 子文本替换 (text, 子项式, 基础算式 (子项式), , , 真)<br /> 跳出循环 ()<br /> .如果真结束<br /> <br /> .判断循环尾 ()<br /> 加入成员 (总项式数组, text)<br /> .计次循环尾 ()<br /> ' 到文本<br /> .如果 (取数组成员数 (项式发布符号) ＝ 0)<br /> 结果 ＝ text<br /> .否则<br /> .计次循环首 (取数组成员数 (总项式数组) ＋ 取数组成员数 (项式发布符号), I)<br /> .如果 (文本_判断奇偶数 (I) ＝ 0)<br /> D ＝ D ＋ 1 ' 偶数<br /> 总项式 ＝ 总项式 ＋ 项式发布符号 [D]<br /> .否则<br /> W ＝ W ＋ 1 ' 奇数<br /> 总项式 ＝ 总项式 ＋ 总项式数组 [W]<br /> .如果结束<br /> <br /> .计次循环尾 ()<br /> 结果 ＝ 基础算式 (总项式)<br /> .如果结束<br /> 返回 (结果)

(“(2+5)*5+6/2*10086”))
[/e]
[/e]
2.很好，现在解决了这个问题，那再看看如何算（a+b-c）类型的值，因为符号都是乱序，所以第一步风格全部符号和文本，再按原先位置排序，得到数组{a，“+”，b，“-”，“c”}，再分成两部分，运算D={a,"+",b}，再运算 结果={D,“-”，c}，实际情况还会有很多分层，例如（a+b-c+d+y+u-t），又要分很多很多次计算

  

子程序名	返回值类型	公开	备 注
基础算式	文本型
参数名	类 型	参考	可空	数组	备 注
参数	文本型

变量名	类 型	静态	数组	备 注
text	文本型
TEXT_E	文本型
数组_符号	文本型		0
替换符号文本	文本型
数组_A	文本型		0
分割文本_A	文本型		0
i	整数型
W	整数型
D	整数型
算术_数组	文本型		0
算术_子I	整数型
算术_子数	文本型
Y	小数型

text ＝ 参数
' 判断要算啥
' 进行拆分算式
TEXT_E ＝ 文本_子文本替换_批量_多换一_自动分割 (text, “1234567890.”, “ ”)
TEXT_E ＝ 子文本替换 (TEXT_E, “ ”, , , , 真)
文本_逐字分割_汇编 (TEXT_E, 数组_符号)
替换符号文本 ＝ 文本_子文本替换_批量单个对应替换 (参数, { “*”, “/”, “+”, “-” }, { “#”, “#”, “#”, “#” })
分割文本_A ＝ 分割文本 (替换符号文本, “#”, )
' 通常符号比数字少1个
如果真 (取数组成员数 (数组_符号) － 取数组成员数 (分割文本_A) ≠ -1)
调试输出 (“错误啦！”)
' * 数组:2{“+”,“/”}
' * 数组:3{“1”,“2”,“2”}
' 调试输出 (数组_符号)
' 合并数组：
计次循环首 (取数组成员数 (分割文本_A) ＋ 取数组成员数 (数组_符号), i)
如果 (文本_判断奇偶数 (i) ＝ 0)
' 偶数
W ＝ W ＋ 1
加入成员 (算术_数组, 数组_符号 [W])
' 奇数
D ＝ D ＋ 1
加入成员 (算术_数组, 分割文本_A [D])

计次循环尾 ()
' 算术_数组
' * 数组:5{“1”,“+”,“2”,“/”,“2”}
' 这里先算除法
判断循环首 (数组_寻找数组_一次 (算术_数组, “/”) ≠ 0)
算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “/”)
算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]
删除成员 (算术_数组, 算术_子I － 1, 3)
插入成员 (算术_数组, 算术_子I － 1, 到文本 (基础单项式算法 (算术_子数)))
判断循环尾 ()
' 算乘法
判断循环首 (数组_寻找数组_一次 (算术_数组, “*”) ≠ 0)
算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “*”)
算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]
删除成员 (算术_数组, 算术_子I － 1, 3)
插入成员 (算术_数组, 算术_子I － 1, 到文本 (基础单项式算法 (算术_子数)))
判断循环尾 ()
' 算-法
' 调试输出 (算术_数组)
判断循环首 (数组_寻找数组_一次 (算术_数组, “-”) ≠ 0)
算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “-”)
算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]
删除成员 (算术_数组, 算术_子I － 1, 3)
' 调试输出 (基础单项式算法 (算术_子数))
Y ＝ 基础单项式算法 (算术_子数)
如果 (Y ＜ 0)
加入成员 (算术_数组, “-”)
加入成员 (算术_数组, 到文本 (－Y))
删除成员 (算术_数组, 1, 1)

插入成员 (算术_数组, 算术_子I － 1, 到文本 (Y))

判断循环尾 ()
' 调试输出 (算术_数组)
' 算加法
判断循环首 (数组_寻找数组_一次 (算术_数组, “+”) ≠ 0)
算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “+”)
算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]
删除成员 (算术_数组, 算术_子I － 1, 3)
插入成员 (算术_数组, 算术_子I － 1, 到文本 (基础单项式算法 (算术_子数)))
判断循环尾 ()
返回 (算术_数组 [1])

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 基础算式, 文本型<br /> .参数 参数, 文本型<br /> .局部变量 text, 文本型<br /> .局部变量 TEXT_E, 文本型<br /> .局部变量 数组_符号, 文本型, , "0"<br /> .局部变量 替换符号文本, 文本型<br /> .局部变量 数组_A, 文本型, , "0"<br /> .局部变量 分割文本_A, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 W, 整数型<br /> .局部变量 D, 整数型<br /> .局部变量 算术_数组, 文本型, , "0"<br /> .局部变量 算术_子I, 整数型<br /> .局部变量 算术_子数, 文本型<br /> .局部变量 Y, 小数型<br /> <br /> text ＝ 参数<br /> ' 判断要算啥<br /> ' 进行拆分算式<br /> TEXT_E ＝ 文本_子文本替换_批量_多换一_自动分割 (text, “1234567890.”, “ ”)<br /> TEXT_E ＝ 子文本替换 (TEXT_E, “ ”, , , , 真)<br /> 文本_逐字分割_汇编 (TEXT_E, 数组_符号)<br /> 替换符号文本 ＝ 文本_子文本替换_批量单个对应替换 (参数, { “*”, “/”, “+”, “-” }, { “#”, “#”, “#”, “#” })<br /> 分割文本_A ＝ 分割文本 (替换符号文本, “#”, )<br /> ' 通常符号比数字少1个<br /> .如果真 (取数组成员数 (数组_符号) － 取数组成员数 (分割文本_A) ≠ -1)<br /> 调试输出 (“错误啦！”)<br /> .如果真结束<br /> ' * 数组:2{“+”,“/”}<br /> ' * 数组:3{“1”,“2”,“2”}<br /> ' 调试输出 (数组_符号)<br /> ' 合并数组：<br /> .计次循环首 (取数组成员数 (分割文本_A) ＋ 取数组成员数 (数组_符号), i)<br /> .如果 (文本_判断奇偶数 (i) ＝ 0)<br /> ' 偶数<br /> W ＝ W ＋ 1<br /> 加入成员 (算术_数组, 数组_符号 [W])<br /> .否则<br /> ' 奇数<br /> D ＝ D ＋ 1<br /> 加入成员 (算术_数组, 分割文本_A [D])<br /> .如果结束<br /> <br /> .计次循环尾 ()<br /> ' 算术_数组<br /> ' * 数组:5{“1”,“+”,“2”,“/”,“2”}<br /> ' 这里先算除法<br /> .判断循环首 (数组_寻找数组_一次 (算术_数组, “/”) ≠ 0)<br /> 算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “/”)<br /> 算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]<br /> 删除成员 (算术_数组, 算术_子I － 1, 3)<br /> 插入成员 (算术_数组, 算术_子I － 1, 到文本 (基础单项式算法 (算术_子数)))<br /> .判断循环尾 ()<br /> ' 算乘法<br /> .判断循环首 (数组_寻找数组_一次 (算术_数组, “*”) ≠ 0)<br /> 算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “*”)<br /> 算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]<br /> 删除成员 (算术_数组, 算术_子I － 1, 3)<br /> 插入成员 (算术_数组, 算术_子I － 1, 到文本 (基础单项式算法 (算术_子数)))<br /> .判断循环尾 ()<br /> ' 算-法<br /> ' 调试输出 (算术_数组)<br /> .判断循环首 (数组_寻找数组_一次 (算术_数组, “-”) ≠ 0)<br /> 算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “-”)<br /> 算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]<br /> 删除成员 (算术_数组, 算术_子I － 1, 3)<br /> ' 调试输出 (基础单项式算法 (算术_子数))<br /> Y ＝ 基础单项式算法 (算术_子数)<br /> .如果 (Y ＜ 0)<br /> 加入成员 (算术_数组, “-”)<br /> 加入成员 (算术_数组, 到文本 (－Y))<br /> 删除成员 (算术_数组, 1, 1)<br /> <br /> .否则<br /> 插入成员 (算术_数组, 算术_子I － 1, 到文本 (Y))<br /> .如果结束<br /> <br /> .判断循环尾 ()<br /> ' 调试输出 (算术_数组)<br /> ' 算加法<br /> .判断循环首 (数组_寻找数组_一次 (算术_数组, “+”) ≠ 0)<br /> 算术_子I ＝ 数组_寻找数组_一次 (算术_数组, “+”)<br /> 算术_子数 ＝ 算术_数组 [算术_子I － 1] ＋ 算术_数组 [算术_子I] ＋ 算术_数组 [算术_子I ＋ 1]<br /> 删除成员 (算术_数组, 算术_子I － 1, 3)<br /> 插入成员 (算术_数组, 算术_子I － 1, 到文本 (基础单项式算法 (算术_子数)))<br /> .判断循环尾 ()<br /> 返回 (算术_数组 [1])

3.更具上面，现在需要计算（a+b）这样的简单式子，及两个数的加减乘除，这里不包含三个数，这是最简单的，取符号左右两边，再进行算术，得出答案

  

子程序名	返回值类型	公开	备 注
基础单项式算法	小数型
参数名	类 型	参考	可空	数组	备 注
text	文本型

变量名	类 型	静态	数组	备 注
算数组	文本型		0

' 调试输出 (text, , )
如果真 (文本_是否存在_逻辑 (text, “*”))
' 乘法 ＝ 真
算数组 ＝ 分割文本 (text, “*”, 2)
返回 (到小数 (算数组 [1]) × 到小数 (算数组 [2]))
如果真 (文本_是否存在_逻辑 (text, “/”))
' 除法 ＝ 真
算数组 ＝ 分割文本 (text, “/”, 2)
返回 (到小数 (算数组 [1]) ÷ 到小数 (算数组 [2]))
如果真 (文本_是否存在_逻辑 (text, “-”))
' 减法 ＝ 真
如果 (取文本左边 (text, 1) ＝ “-”)
' 调试输出 (text)
如果 (文本_取出现次数 (text, “-”, 假) ＝ 2)
text ＝ 取文本右边 (text, 取文本长度 (text) － 1)
算数组 ＝ 分割文本 (text, “-”, 2)
如果真 (取数组成员数 (算数组) ＝ 1)
插入成员 (算数组, 1, “0”)
返回 (���到小数 (算数组 [1]) － 到小数 (算数组 [2]))
算数组 ＝ 分割文本 (text, “-”, 2)
' 调试输出 (算数组)
返回 (到小数 (算数组 [2]) － 到小数 (算数组 [1]))

算数组 ＝ 分割文本 (text, “-”, 2)
返回 (到小数 (算数组 [1]) － 到小数 (算数组 [2]))

如果真 (文本_是否存在_逻辑 (text, “+”))
' 加法 ＝ 真
算数组 ＝ 分割文本 (text, “+”, 2)
返回 (到小数 (算数组 [1]) ＋ 到小数 (算数组 [2]))
返回 (0)

.版本 2<br /> <br /> .子程序 基础单项式算法, 小数型<br /> .参数 text, 文本型<br /> .局部变量 算数组, 文本型, , "0"<br /> <br /> ' 调试输出 (text, , )<br /> .如果真 (文本_是否存在_逻辑 (text, “*”))<br /> ' 乘法 ＝ 真<br /> 算数组 ＝ 分割文本 (text, “*”, 2)<br /> 返回 (到小数 (算数组 [1]) × 到小数 (算数组 [2]))<br /> .如果真结束<br /> .如果真 (文本_是否存在_逻辑 (text, “/”))<br /> ' 除法 ＝ 真<br /> 算数组 ＝ 分割文本 (text, “/”, 2)<br /> 返回 (到小数 (算数组 [1]) ÷ 到小数 (算数组 [2]))<br /> .如果真结束<br /> .如果真 (文本_是否存在_逻辑 (text, “-”))<br /> ' 减法 ＝ 真<br /> .如果 (取文本左边 (text, 1) ＝ “-”)<br /> ' 调试输出 (text)<br /> .如果 (文本_取出现次数 (text, “-”, 假) ＝ 2)<br /> text ＝ 取文本右边 (text, 取文本长度 (text) － 1)<br /> 算数组 ＝ 分割文本 (text, “-”, 2)<br /> .如果真 (取数组成员数 (算数组) ＝ 1)<br /> 插入成员 (算数组, 1, “0”)<br /> .如果真结束<br /> 返回 (－到小数 (算数组 [1]) － 到小数 (算数组 [2]))<br /> .否则<br /> 算数组 ＝ 分割文本 (text, “-”, 2)<br /> ' 调试输出 (算数组)<br /> 返回 (到小数 (算数组 [2]) － 到小数 (算数组 [1]))<br /> .如果结束<br /> <br /> .否则<br /> 算数组 ＝ 分割文本 (text, “-”, 2)<br /> 返回 (到小数 (算数组 [1]) － 到小数 (算数组 [2]))<br /> .如果结束<br /> <br /> .如果真结束<br /> .如果真 (文本_是否存在_逻辑 (text, “+”))<br /> ' 加法 ＝ 真<br /> 算数组 ＝ 分割文本 (text, “+”, 2)<br /> 返回 (到小数 (算数组 [1]) ＋ 到小数 (算数组 [2]))<br /> .如果真结束<br /> 返回 (0)

以下附上成品代码
文本.e (25.39 KB, 下载次数: 5)

4 天前 上传

点击文件名下载附件

卡卡1111

支持开源~！感谢分享

落雪无尘

不错 玩的可以