字符串表达式计算(a+b/(a-b))的思路与实践

南七星之家 · 2023-11-27 00:05:39

前言

为满足业务需要，需要为项目中自定义模板添加一个计算字段的组件，通过设置字符串表达式，使用时在改变表达式其中一个字段的数据时，自动计算另外一个字段的值。
本篇为上篇，介绍原理，简单实现一个工具，输入字符串表达式，解析其中的参数，输入参数计算结果。
下篇将基于此封装实现对Mongo查询语法的封装，通过addFields的方式转换表达式，后续等封装成NuGet包再分享

实现如下所示

输入 1+1 输出 2
输入 a+1 参数a:1 输出 2
输入 (a+1)*b 输入a:1,b:1 输出 2
输入 (a+1-(2+a)*3/3)/a+3 输入a:1 输出 2

复制代码

实现思路

想要实现上面这个功能，需要先了解诸如 (a+1-(2+a)*3/3)/a+3 这个是什么？

维基百科：中缀表示法（或中缀记法）是一个通用的算术或逻辑公式表示方法，操作符是以中缀形式处于操作数的中间（例：3 + 4）。与前缀表达式（例：+ 3 4 ）或后缀表达式（例：3 4 + ）相比，中缀表达式不容易被电脑解析逻辑优先顺序，但仍被许多程序语言使用，因为它符合大多数自然语言的写法。
前缀表示法（+ 3 4 ）也叫波兰表示法
后缀表示法（3 4 + ）也叫逆波兰表示法

在维基百科的说明中，也给出了和其相关的另外两种表示法，以及用于把中缀表达式转换到后缀表达式或树的算法：调度场算法，如下图所示

实现代码

找了很多的开源项目，最终基于 qinfengzhu/Evaluator ，实现了上述功能。
调用代码

using Evaluator;
using System.Text.RegularExpressions;
Console.WriteLine("字符串表达式计算工具");
EvalTest();
void EvalTest()
{
Console.WriteLine("----------------------------------------------------");
var parse = new EvalParser();
Console.Write("请输入表达式：");//a+b*3/5+a
var evalStr = Console.ReadLine();
if (string.IsNullOrEmpty(evalStr))
{
Console.WriteLine("Game Over");
return;
}
//解析其中的变量并让用户输入
var matchs = Regex.Matches(evalStr, @"\b[\w$]+\b");
var paramsDic = new Dictionary<string, object>();
//预定义参数
paramsDic.Add("now_year", DateTime.Now.Year);
paramsDic.Add("now_month", DateTime.Now.Month);
paramsDic.Add("now_day", DateTime.Now.Day);
foreach (Match match in matchs)
{
if (decimal.TryParse(match.Value, out decimal kp))
continue;
if (!paramsDic.ContainsKey(match.Value))
{
Console.Write($"请输入数字变量【{match.Value}】：");
var paramValue = Console.ReadLine();
decimal dvalue;
while (!decimal.TryParse(paramValue, out dvalue))
{
Console.WriteLine($"输入有误，请输入数字变量【{match.Value}】：");
paramValue = Console.ReadLine();
}
paramsDic.Add(match.Value, dvalue);
}
}
var result = parse.EvalNumber(evalStr, paramsDic);
Console.WriteLine($"结果：{result}");
EvalTest();
}

复制代码

EvalParser 类的实现

通过上面调用代码可以看到，核心的计算类是 EvalParser ，调用其 EvalNumber 进行计算
EvalNumber 实现

EvalNumber 方法,主要分为3步
- 第一步将表达式解析转换到队列中，即将中缀表达式，转换成后缀表达式
- 第二步将队列中的表达式加入表达式栈中
- 第三步使用表达式树进行计算
返回值处理
- 已知的错误有除以0和溢出的异常，所以直接捕获返回null，也可以在计算除数的时候判断值为0就直接返回null，
- 精度处理
EvalNumber 计算核心代码
- 1. /// <summary>
  2. /// 计算表达式的计算结果
  3. /// </summary>
  4. /// <param name="expression">表达式</param>
  5. /// <param name="dynamicObject">动态对象</param>
  6. /// <param name="precision">精度默认2</param>
  7. /// <returns>计算的结果</returns>
  8. public decimal? EvalNumber(string expression, Dictionary<string, object> dynamicObject, int precision = 2)
  9. {
  10. var values = dynamicObject ?? new Dictionary<string, object>();
  11. //中缀表达式，转换成后缀表达式并入列
  12. var queue = ParserInfixExpression(expression, values);
  13. var cacheStack = new Stack<Expression>();
  14. while (queue.Count > 0)
  15. {
  16. var item = queue.Dequeue();
  17. if (item.ItemType == EItemType.Value && item.IsConstant)
  18. {
  19. var itemExpression = Expression.Constant(item.Value);
  20. cacheStack.Push(itemExpression);
  21. continue;
  22. }
  23. if (item.ItemType == EItemType.Value && !item.IsConstant)
  24. {
  25. var propertyName = item.Content.Trim();
  26. //将参数替换回来
  27. propertyName = PreReplaceTextToOprator(propertyName, values);
  28. //参数为空的情况
  29. if (!values.ContainsKey(propertyName) || values[propertyName] == null || !decimal.TryParse(values[propertyName].ToString(), out decimal propertyValue))
  30. return null;
  31. //var propertyValue = decimal.Parse(values[propertyName].ToString());
  32. var itemExpression = Expression.Constant(propertyValue);
  33. cacheStack.Push(itemExpression);
  34. }
  35. if (item.ItemType == EItemType.Operator)
  36. {
  37. if (cacheStack.Count <= 1)
  38. continue;
  39. Expression firstParamterExpression = Expression.Empty();
  40. Expression secondParamterExpression = Expression.Empty();
  41. switch (item.Content[0])
  42. {
  43. case EvalParser.AddOprator:
  44. firstParamterExpression = cacheStack.Pop();
  45. secondParamterExpression = cacheStack.Pop();
  46. var addExpression = Expression.Add(secondParamterExpression, firstParamterExpression);
  47. cacheStack.Push(addExpression);
  48. break;
  49. case EvalParser.DivOperator:
  50. firstParamterExpression = cacheStack.Pop();
  51. secondParamterExpression = cacheStack.Pop();
  52. var divExpression = Expression.Divide(secondParamterExpression, firstParamterExpression);
  53. cacheStack.Push(divExpression);
  54. break;
  55. case EvalParser.MulOperator:
  56. firstParamterExpression = cacheStack.Pop();
  57. secondParamterExpression = cacheStack.Pop();
  58. var mulExpression = Expression.Multiply(secondParamterExpression, firstParamterExpression);
  59. cacheStack.Push(mulExpression);
  60. break;
  61. case EvalParser.SubOperator:
  62. firstParamterExpression = cacheStack.Pop();
  63. secondParamterExpression = cacheStack.Pop();
  64. var subExpression = Expression.Subtract(secondParamterExpression, firstParamterExpression);
  65. cacheStack.Push(subExpression);
  66. break;
  67. case EvalParser.LBraceOperator:
  68. case EvalParser.RBraceOperator:
  69. continue;
  70. default:
  71. throw new Exception("计算公式错误");
  72. }
  73. }
  74. }
  75. if (cacheStack.Count == 0)
  76. return null;
  77. var lambdaExpression = Expression.Lambda<Func<decimal>>(cacheStack.Pop());
  78. try
  79. {
  80. // 除0 溢出
  81. var value = lambdaExpression.Compile()();
  82. return Math.Round(value, precision);
  83. }
  84. catch (Exception ex)
  85. {
  86. //System.OverflowException
  87. //System.DivideByZeroException
  88. if (ex is DivideByZeroException
  89. || ex is OverflowException)
  90. return null;
  91. throw ex;
  92. }
  93. }
  复制代码
PreParserInfixExpression 计算嵌套(),以及先行计算纯数字，主要是在后面转换为mongo语法的时候用到，让纯数字计算在内存中运行而不是数据库中计算
- 1. /// <summary>
  2. /// 符号转换字典
  3. /// </summary>
  4. private static Dictionary<char, string> OperatorToTextDic = new Dictionary<char, string>()
  5. {
  6. { '+', "_JIA_" },
  7. { '-', "_JIAN_" },
  8. { '/', "_CHENG_" },
  9. { '*', "_CHU_" },
  10. { '(', "_ZKH_" },
  11. { ')', "_YKH_" }
  12. };
  13. /// <summary>
  14. /// 预处理参数符号转文本
  15. /// </summary>
  16. /// <param name="expression"></param>
  17. /// <param name="dynamicObject"></param>
  18. /// <returns></returns>
  19. public string PreReplaceOpratorToText(string expression, Dictionary<string, object> dynamicObject)
  20. {
  21. //如果是参数里面包含了括号,将其中的参数替换成特殊字符
  22. var existOperatorKeys = dynamicObject.Keys.Where(s => OperatorToTextDic.Keys.Any(s2 => s.Contains(s2))).ToList();
  23. //存在特殊字符变量的
  24. if (existOperatorKeys.Any())
  25. {
  26. //将符号替换成字母
  27. foreach (var s in existOperatorKeys)
  28. {
  29. var newKey = s;
  30. foreach (var s2 in OperatorToTextDic)
  31. {
  32. newKey = newKey.Replace(s2.Key.ToString(), s2.Value);
  33. }
  34. expression = expression.Replace(s, newKey);
  35. }
  36. }
  37. return expression;
  38. }
  复制代码

ParserInfixExpression 表达式转换核心代码

1. /// <summary>
2. /// 预处理计算表达式
3. /// </summary>
4. /// <param name="expression">表达式</param>
5. /// <param name="dynamicObject">参数</param>
6. /// <param name="isCompile">是否是编译</param>
7. /// <returns></returns>
8. public string PreParserInfixExpression(string expression, Dictionary<string, object> dynamicObject, bool isCompile = false)
9. {
10. expression = expression.Trim();
11. string pattern = @"((.*?))";
12. Match match = Regex.Match(expression, pattern);
13. if (match.Success && match.Groups.Count > 1)
14. {
15. var constText = match.Groups[0].Value;
16. var constValue = match.Groups[1].Value;
17. string numPattern = @"(([\s|0-9|+-*/|.]+))";
18. //纯数字计算或者不是编译预约
19. if (Regex.IsMatch(constText, numPattern) || !isCompile)
20. {
21. var evalValue = EvalNumber(constValue, dynamicObject);
22. if (evalValue == null)
23. return string.Empty;
24. var replaceText = evalValue.ToString();
25. expression = expression.Replace(constText, replaceText);
26. }
27. else if (isCompile)
28. {
29. //编译计算
30. var completeText = Compile(constValue, dynamicObject).ToString();
31. //临时参数Key
32. var tempPramKey = "temp_" + Guid.NewGuid().ToString("n");
33. dynamicObject.Add(tempPramKey, completeText);
34. expression = expression.Replace(constText, tempPramKey);
35. }
36. else
37. {
38. return expression;
39. }
40. return PreParserInfixExpression(expression, dynamicObject, isCompile);
41. }
42. return expression;
43. }
复制代码

</ul>EvalDate 实现指定日期类型输出

因项目需要，需要将当前日期，当前时间加入默认变量，并支持加入计算公式中，计算的结果也可以选择是日期或者数值。
需要实现这个功能，需要先定义好，时间如何计算，我们将日期时间转换成时间戳来进行转换后参与计算，计算完成后再转换成日期即可。
所以只需要在上面的数值计算包裹一层就可以得到日期的计算结果

EvalDate 核心代码
- 1. /// <summary>
  2. /// 转换表达式
  3. /// </summary>
  4. /// <param name="expression"></param>
  5. /// <param name="dynamicObject"></param>
  6. /// <param name="isComplete"></param>
  7. /// <returns></returns>
  8. public Queue<EvalItem> ParserInfixExpression(string expression, Dictionary<string, object> dynamicObject, bool isComplete = false)
  9. {
  10. var queue = new Queue<EvalItem>();
  11. if (string.IsNullOrEmpty(expression))
  12. return queue;
  13. expression = PreReplaceOpratorToText(expression, dynamicObject);
  14. expression = PreParserInfixExpression(expression, dynamicObject, isComplete);
  15. if (string.IsNullOrEmpty(expression))
  16. return queue;
  17. var operatorStack = new Stack<OperatorChar>();
  19. int index = 0;
  20. int itemLength = 0;
  21. //当第一个字符为+或者-的时候
  22. char firstChar = expression[0];
  23. if (firstChar == AddOprator || firstChar == SubOperator)
  24. {
  25. expression = string.Concat("0", expression);
  26. }
  27. int expressionLength = expression.Length;
  28. using (var scanner = new StringReader(expression))
  29. {
  30. string operatorPreItem = string.Empty;
  31. while (scanner.Peek() > -1)
  32. {
  33. char currentChar = (char)scanner.Read();
  34. switch (currentChar)
  35. {
  36. case AddOprator:
  37. case SubOperator:
  38. case DivOperator:
  39. case MulOperator:
  40. case LBraceOperator:
  41. case RBraceOperator:
  42. //直接把数字压入到队列中
  43. operatorPreItem = expression.Substring(index, itemLength);
  44. if (operatorPreItem != "")
  45. {
  46. var numberItem = new EvalItem(EItemType.Value, operatorPreItem);
  47. queue.Enqueue(numberItem);
  48. }
  49. index = index + itemLength + 1;
  50. itemLength = -1;
  51. //当前操作符
  52. var currentOperChar = new OperatorChar() { Operator = currentChar };
  53. if (operatorStack.Count == 0)
  54. {
  55. operatorStack.Push(currentOperChar);
  56. break;
  57. }
  58. //处理当前操作符与操作字符栈进出
  59. var topOperator = operatorStack.Peek();
  60. //若当前操作符为(或者栈顶元素为(则直接入栈
  61. if (currentOperChar == LBraceOperatorChar || topOperator == LBraceOperatorChar)
  62. {
  63. operatorStack.Push(currentOperChar);
  64. break;
  65. }
  66. //若当前操作符为),则栈顶元素顺序输出到队列,至到栈顶元素(输出为止,单(不进入队列,它自己也不进入队列
  67. if (currentOperChar == RBraceOperatorChar)
  68. {
  69. while (operatorStack.Count > 0)
  70. {
  71. if (operatorStack.Peek() != LBraceOperatorChar)
  72. {
  73. var operatorItem = new EvalItem(EItemType.Operator, operatorStack.Pop().GetContent());
  74. queue.Enqueue(operatorItem);
  75. }
  76. else
  77. {
  78. break;
  79. }
  80. }
  81. if (operatorStack.Count > 0 && operatorStack.Peek() == RBraceOperatorChar)
  82. {
  83. operatorStack.Pop();
  84. }
  85. break;
  86. }
  87. //若栈顶元素优先级高于当前元素，则栈顶元素输出到队列,当前元素入栈
  88. if (topOperator.Level > currentOperChar.Level || topOperator.Level == currentOperChar.Level)
  89. {
  90. var topActualOperator = operatorStack.Pop();
  91. var operatorItem = new EvalItem(EItemType.Operator, topActualOperator.GetContent());
  92. queue.Enqueue(operatorItem);
  94. while (operatorStack.Count > 0)
  95. {
  96. var tempTop = operatorStack.Peek();
  97. if (tempTop.Level > currentOperChar.Level || tempTop.Level == currentOperChar.Level)
  98. {
  99. var topTemp = operatorStack.Pop();
  100. var operatorTempItem = new EvalItem(EItemType.Operator, topTemp.GetContent());
  101. queue.Enqueue(operatorTempItem);
  102. }
  103. else
  104. {
  105. break;
  106. }
  107. }
  108. operatorStack.Push(currentOperChar);
  109. }
  110. //当当前元素小于栈顶元素的时候，当前元素直接入栈
  111. else
  112. {
  113. operatorStack.Push(currentOperChar);
  114. }
  115. break;
  116. default:
  117. break;
  118. }
  119. itemLength++;
  120. }
  121. }
  122. //剩余无符号的字符串
  123. if (index < expressionLength)
  124. {
  125. string lastNumber = expression.Substring(index, expressionLength - index);
  126. var lastNumberItem = new EvalItem(EItemType.Value, lastNumber);
  127. queue.Enqueue(lastNumberItem);
  128. }
  129. //弹出栈中所有操作符号
  130. if (operatorStack.Count > 0)
  131. {
  132. while (operatorStack.Count != 0)
  133. {
  134. var topOperator = operatorStack.Pop();
  135. var operatorItem = new EvalItem(EItemType.Operator, topOperator.GetContent());
  136. queue.Enqueue(operatorItem);
  137. }
  138. }
  139. return queue;
  140. }
  复制代码

代码中的数据定义

其他数据定义 OperatorChar EvalItem EItemType CharExtension 可以查看完整demo
相关说明

相关算法：中缀表达式，后缀表达式，逆波兰算法，调度场算法
相关语言：C#
参考项目：qinfengzhu/Evaluator
本文Demo: DevopsDemo/EvalDemo

后语

期间找了很多开源项目参考，需求的独特性，最终是实现了功能
整个计算字段的实现花了3周时间，终于是顺利上线。
沉迷学习，无法自拔。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

		自动登录	找回密码
密码			立即注册

字符串表达式计算(a+b/(a-b))的思路与实践

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块