首页 > 其他分享 >字符串表达式计算(a+b/(a-b))的思路与实践

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

时间：2023-10-31 09:23:34浏览次数：36  
标签：return operatorStack var 字符串 思路 expression 表达式 string

前言

为满足业务需要，需要为项目中自定义模板添加一个计算字段的组件，通过设置字符串表达式，使用时在改变表达式其中一个字段的数据时，自动计算另外一个字段的值。

本篇为上篇，介绍原理，简单实现一个工具，输入字符串表达式，解析其中的参数，输入参数计算结果。

下篇将基于此封装实现对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 计算核心代码

    • /// <summary>
/// 计算表达式的计算结果
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="dynamicObject">动态对象</param>
/// <param name="precision">精度 默认2</param>
/// <returns>计算的结果</returns>
public decimal? EvalNumber(string expression, Dictionary<string, object> dynamicObject, int precision = 2)
{
    var values = dynamicObject ?? new Dictionary<string, object>();
    //中缀表达式，转换成后缀表达式并入列
    var queue = ParserInfixExpression(expression, values);
    var cacheStack = new Stack<Expression>();
    while (queue.Count > 0)
    {
        var item = queue.Dequeue();
        if (item.ItemType == EItemType.Value && item.IsConstant)
        {
            var itemExpression = Expression.Constant(item.Value);
            cacheStack.Push(itemExpression);
            continue;
        }
        if (item.ItemType == EItemType.Value && !item.IsConstant)
        {
            var propertyName = item.Content.Trim();
            //将参数替换回来
            propertyName = PreReplaceTextToOprator(propertyName, values);
            //参数为空的情况
            if (!values.ContainsKey(propertyName) || values[propertyName] == null || !decimal.TryParse(values[propertyName].ToString(), out decimal propertyValue))
                return null;
            //var propertyValue = decimal.Parse(values[propertyName].ToString());
            var itemExpression = Expression.Constant(propertyValue);
            cacheStack.Push(itemExpression);
        }
        if (item.ItemType == EItemType.Operator)
        {
            if (cacheStack.Count <= 1)
                continue;
            Expression firstParamterExpression = Expression.Empty();
            Expression secondParamterExpression = Expression.Empty();
            switch (item.Content[0])
            {
                case EvalParser.AddOprator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var addExpression = Expression.Add(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(addExpression);
                    break;
                case EvalParser.DivOperator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var divExpression = Expression.Divide(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(divExpression);
                    break;
                case EvalParser.MulOperator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var mulExpression = Expression.Multiply(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(mulExpression);
                    break;
                case EvalParser.SubOperator:
                    firstParamterExpression = cacheStack.Pop();
                    secondParamterExpression = cacheStack.Pop();
                    var subExpression = Expression.Subtract(secondParamterExpression, firstParamterExpression);
                    cacheStack.Push(subExpression);
                    break;
                case EvalParser.LBraceOperator:
                case EvalParser.RBraceOperator:
                    continue;
                default:
                    throw new Exception("计算公式错误");
            }
        }
    }
    if (cacheStack.Count == 0)
        return null;
    var lambdaExpression = Expression.Lambda<Func<decimal>>(cacheStack.Pop());
    try
    {
        // 除0 溢出
        var value = lambdaExpression.Compile()();
        return Math.Round(value, precision);
    }
    catch (Exception ex)
    {
        //System.OverflowException
        //System.DivideByZeroException
        if (ex is DivideByZeroException
            || ex is OverflowException)
            return null;
        throw ex;
    }
}

ParserInfixExpression 实现

  • 在EvalNumber 方法的第一步调用了 ParserInfixExpression 方法来进行表达式的预处理

    • PreReplaceOpratorToText 如果变量中带有一些计算符号(+-*/())，通过这个方法转换临时变量，在获取值的时候再转换回来

      • 
/// <summary>
/// 符号转换字典
/// </summary>
private static Dictionary<char, string> OperatorToTextDic = new Dictionary<char, string>()
{
    { '+', "_JIA_" },
    { '-', "_JIAN_" },
    { '/', "_CHENG_" },
    { '*', "_CHU_" },
    { '(', "_ZKH_" },
    { ')', "_YKH_" }
};
/// <summary>
/// 预处理参数符号转文本
/// </summary>
/// <param name="expression"></param>
/// <param name="dynamicObject"></param>
/// <returns></returns>
public string PreReplaceOpratorToText(string expression, Dictionary<string, object> dynamicObject)
{
    //如果是参数里面包含了括号,将其中的参数替换成特殊字符
    var existOperatorKeys = dynamicObject.Keys.Where(s => OperatorToTextDic.Keys.Any(s2 => s.Contains(s2))).ToList();
    //存在特殊字符变量的
    if (existOperatorKeys.Any())
    {
        //将符号替换成字母
        foreach (var s in existOperatorKeys)
        {
            var newKey = s;
            foreach (var s2 in OperatorToTextDic)
            {
                newKey = newKey.Replace(s2.Key.ToString(), s2.Value);
            }
            expression = expression.Replace(s, newKey);
        }
    }
    return expression;
}

    • PreParserInfixExpression 计算嵌套(),以及先行计算纯数字，主要是在后面转换为mongo语法的时候用到，让纯数字计算在内存中运行而不是数据库中计算

      • /// <summary>
/// 预处理计算表达式
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="dynamicObject">参数</param>
/// <param name="isCompile">是否是编译</param>
/// <returns></returns>
public string PreParserInfixExpression(string expression, Dictionary<string, object> dynamicObject, bool isCompile = false)
{
    expression = expression.Trim();
    string pattern = @"((.*?))";
    Match match = Regex.Match(expression, pattern);
    if (match.Success && match.Groups.Count > 1)
    {
        var constText = match.Groups[0].Value;
        var constValue = match.Groups[1].Value;
        string numPattern = @"(([\s|0-9|+-*/|.]+))";
        //纯数字计算 或者 不是编译预约
        if (Regex.IsMatch(constText, numPattern) || !isCompile)
        {
            var evalValue = EvalNumber(constValue, dynamicObject);
            if (evalValue == null)
                return string.Empty;
            var replaceText = evalValue.ToString();
            expression = expression.Replace(constText, replaceText);
        }
        else if (isCompile)
        {
            //编译计算
            var completeText = Compile(constValue, dynamicObject).ToString();
            //临时参数Key
            var tempPramKey = "temp_" + Guid.NewGuid().ToString("n");
            dynamicObject.Add(tempPramKey, completeText);
            expression = expression.Replace(constText, tempPramKey);
        }
        else
        {
            return expression;
        }
        return PreParserInfixExpression(expression, dynamicObject, isCompile);
    }
    return expression;
}

  • ParserInfixExpression 表达式转换核心代码

    • /// <summary>
/// 转换表达式
/// </summary>
/// <param name="expression"></param>
/// <param name="dynamicObject"></param>
/// <param name="isComplete"></param>
/// <returns></returns>
public Queue<EvalItem> ParserInfixExpression(string expression, Dictionary<string, object> dynamicObject, bool isComplete = false)
{
    var queue = new Queue<EvalItem>();
    if (string.IsNullOrEmpty(expression))
        return queue;
    expression = PreReplaceOpratorToText(expression, dynamicObject);
    expression = PreParserInfixExpression(expression, dynamicObject, isComplete);
    if (string.IsNullOrEmpty(expression))
        return queue;
    var operatorStack = new Stack<OperatorChar>();

    int index = 0;
    int itemLength = 0;
    //当第一个字符为+或者-的时候
    char firstChar = expression[0];
    if (firstChar == AddOprator || firstChar == SubOperator)
    {
        expression = string.Concat("0", expression);
    }
    int expressionLength = expression.Length;
    using (var scanner = new StringReader(expression))
    {
        string operatorPreItem = string.Empty;
        while (scanner.Peek() > -1)
        {
            char currentChar = (char)scanner.Read();
            switch (currentChar)
            {
                case AddOprator:
                case SubOperator:
                case DivOperator:
                case MulOperator:
                case LBraceOperator:
                case RBraceOperator:
                    //直接把数字压入到队列中
                    operatorPreItem = expression.Substring(index, itemLength);
                    if (operatorPreItem != "")
                    {
                        var numberItem = new EvalItem(EItemType.Value, operatorPreItem);
                        queue.Enqueue(numberItem);
                    }
                    index = index + itemLength + 1;
                    itemLength = -1;
                    //当前操作符
                    var currentOperChar = new OperatorChar() { Operator = currentChar };
                    if (operatorStack.Count == 0)
                    {
                        operatorStack.Push(currentOperChar);
                        break;
                    }
                    //处理当前操作符与操作字符栈进出
                    var topOperator = operatorStack.Peek();
                    //若当前操作符为(或者栈顶元素为(则直接入栈
                    if (currentOperChar == LBraceOperatorChar || topOperator == LBraceOperatorChar)
                    {
                        operatorStack.Push(currentOperChar);
                        break;
                    }
                    //若当前操作符为),则栈顶元素顺序输出到队列,至到栈顶元素(输出为止,单(不进入队列,它自己也不进入队列
                    if (currentOperChar == RBraceOperatorChar)
                    {
                        while (operatorStack.Count > 0)
                        {
                            if (operatorStack.Peek() != LBraceOperatorChar)
                            {
                                var operatorItem = new EvalItem(EItemType.Operator, operatorStack.Pop().GetContent());
                                queue.Enqueue(operatorItem);
                            }
                            else
                            {
                                break;
                            }
                        }
                        if (operatorStack.Count > 0 && operatorStack.Peek() == RBraceOperatorChar)
                        {
                            operatorStack.Pop();
                        }
                        break;
                    }
                    //若栈顶元素优先级高于当前元素，则栈顶元素输出到队列,当前元素入栈
                    if (topOperator.Level > currentOperChar.Level || topOperator.Level == currentOperChar.Level)
                    {
                        var topActualOperator = operatorStack.Pop();
                        var operatorItem = new EvalItem(EItemType.Operator, topActualOperator.GetContent());
                        queue.Enqueue(operatorItem);

                        while (operatorStack.Count > 0)
                        {
                            var tempTop = operatorStack.Peek();
                            if (tempTop.Level > currentOperChar.Level || tempTop.Level == currentOperChar.Level)
                            {
                                var topTemp = operatorStack.Pop();
                                var operatorTempItem = new EvalItem(EItemType.Operator, topTemp.GetContent());
                                queue.Enqueue(operatorTempItem);
                            }
                            else
                            {
                                break;
                            }
                        }
                        operatorStack.Push(currentOperChar);
                    }
                    //当当前元素小于栈顶元素的时候，当前元素直接入栈
                    else
                    {
                        operatorStack.Push(currentOperChar);
                    }
                    break;
                default:
                    break;
            }
            itemLength++;
        }
    }
    //剩余无符号的字符串
    if (index < expressionLength)
    {
        string lastNumber = expression.Substring(index, expressionLength - index);
        var lastNumberItem = new EvalItem(EItemType.Value, lastNumber);
        queue.Enqueue(lastNumberItem);
    }
    //弹出栈中所有操作符号
    if (operatorStack.Count > 0)
    {
        while (operatorStack.Count != 0)
        {
            var topOperator = operatorStack.Pop();
            var operatorItem = new EvalItem(EItemType.Operator, topOperator.GetContent());
            queue.Enqueue(operatorItem);
        }
    }
    return queue;
}

EvalDate 实现指定日期类型输出

因项目需要，需要将当前日期，当前时间加入默认变量，并支持加入计算公式中，计算的结果也可以选择是日期或者数值。

需要实现这个功能，需要先定义好，时间如何计算，我们将日期时间转换成时间戳来进行转换后参与计算，计算完成后再转换成日期即可。

所以只需要在上面的数值计算包裹一层就可以得到日期的计算结果

  • EvalDate 核心代码

    • /// <summary>
/// 计算表达式的日期结果
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="dynamicObject">动态对象</param>
/// <returns>计算的结果</returns>
public DateTime? EvalDate(string expression, Dictionary<string, object> dynamicObject)
{
    var dateNumValue = EvalNumber(expression, dynamicObject);
    if (dateNumValue == null)
        return null;
    if (long.TryParse(dateNumValue.ToString(), out long dateNum))
    {
        return JsTimeToDateTime(dateNum);
    }
    return null;
}

/// <summary>
/// 毫秒级时间戳转成 DateTime
/// </summary>
/// <param name="unixTimestamp"></param>
/// <returns></returns>
private DateTime JsTimeToDateTime(long unixTimestamp)
{
    return DateTimeOffset.FromUnixTimeMilliseconds(unixTimestamp).LocalDateTime;
}

代码中的数据定义

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

相关说明

后语

期间找了很多开源项目参考，需求的独特性，最终是实现了功能

整个计算字段的实现花了3周时间，终于是顺利上线。

沉迷学习，无法自拔。

标签：return,operatorStack,var,字符串,思路,expression,表达式,string
From： https://www.cnblogs.com/morang/p/csharp-eval.html

相关文章

  • 28. 找出字符串中第一个匹配项的下标
    给你两个字符串haystack和needle，请你在haystack字符串中找出needle字符串的第一个匹配项的下标（下标从0开始）。如果needle不是haystack的一部分，则返回-1。示例1：输入：haystack="sadbutsad",needle="sad"输出：0解释："sad"在下标0和6处匹配。第一个匹......
  • 无涯教程-C语言 - 字符串(String)
    字符串实际上是由null字符'\0'终止的一维字符数组，因此，以零结尾的字符串包含由字符串组成的字符，后跟null。以下声明和初始化创建一个由单词"Hello"组成的字符串。chargreeting[6]={'H','e','l','l','o','\0'};如果您遵循数组初始化的规则，那么您可以编写以下语句，如下......
  • Java 新手如何使用Spring MVC 中的查询字符串和查询参数?
    文章目录什么是查询字符串和查询参数？步骤1:步骤2:步骤3:步骤4:结论......
  • PostgreSQL（kingbaseES） 中，可以使用 unnest 函数将一个包含多个值的字符串分割成多行
    在PostgreSQL中，您可以使用unnest函数将一个包含多个值的字符串分割成多行。unnest函数将一个数组（或者像我们的情况下是由STRING_TO_ARRAY函数生成的数组）展开为多行数据。假设您有一个表my_table，其中包含一个名为my_column的字符串列，其内容如下：my_column-----------......
  • Python如何去掉字符串空格?
    在Python中，当我们使用Python处理字符串时，经常会遇到字符串中包含空格的情况，那么Python如何去掉字符串空格?有多种方法可以从Python字符串中删除空格，以下是详细内容介绍。1、使用strip()方法它是一个Python内置函数，可以用来去除字符串开头和结尾的空格。例如，以下代码将......
  • 数组，list，字符串的一些转换
    //list转数组Long[]ids=updateIds.toArray(newLong[updateIds.size()]) // 数组转listList<String>reasonList=Arrays.asList(perm.trim().split(",")) // String转数组String[]reasons=business.getReason().split(",") //数组转字符串需要引⼊......
  • LeetCode459.重复的子字符串
    题目描述给定一个非空的字符串s，检查是否可以通过由它的一个子串重复多次构成。示例提交的代码十五分钟内没想出来怎么解决，没代码：(学习到的东西因为个人没有想出来怎么解决，看的是Carl大神的解法，地址我放在下面：移动匹配以及KMP解此题然后我写一下我个人理解的地方吧，记录......
  • C++小练习：字符串分割的高性能实现
    字符串分割是日常工作中比较常见的基础函数，通常大家会使用现成的基础库，基础库的性能是否是最佳的？本文基于一个周末小练习，研究如何最大限度的提升字符串分割的性能。  1、背景字符串按照分隔符拆成多个子串在日常工作中很常见，譬如：后台服务对配置的解析、模型服务对输入特征的......
  • 字符串、线性表、队列、栈、哈希表、dfs、bfs
    题目列表：1.字符串无重复字符的最长子串（中等难度）给定一个字符串s，请你找出其中不含有重复字符的最长子串的长度。AC代码，展开查看classSolution{public:intlengthOfLongestSubstring(strings){intres=0;unordered_map<char,int>heap......
  • 逆波兰表达式
    classSolution{publicintevalRPN(String[]tokens){Stackst=newStack();booleanflag=true;intval=0;for(inti=0;i<tokens.length;i++){if("+".equals(tokens[i])){......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99