字符串表達式計算(a+b/(a-b))的思路與實踐

前言

爲滿足業務需要，需要爲項目中自定義模板添加一個計算字段的組件，通過設置字符串表達式，使用時在改變表達式其中一個字段的數據時，自動計算另外一個字段的值。

本篇爲上篇，介紹原理，簡單實現一個工具，輸入字符串表達式，解析其中的參數，輸入參數計算結果。

下篇將基於此封裝實現對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

相關說明

• 相關算法：中綴表達式，後綴表達式，逆波蘭算法，調度場算法
• 相關語言：C#
• 參考項目：qinfengzhu/Evaluator
• 本文Demo: DevopsDemo/EvalDemo

後語

期間找了很多開源項目參考，需求的獨特性，最終是實現了功能

整個計算字段的實現花了3周時間，終於是順利上線。

沉迷學習，無法自拔。