[原创]从中文智能提示到表达式识别与计算

前言

在此处我以表达式“3 + ( 4 * ( 1 + ( 1 + 2 ) ) ) * ( 1 + 2 ) ( 3 + 2 )”，虽然谈到是中文提示到这篇的，但是为了画图和解释方便，暂且用数字直接代替。

事实上，中文表达式到具体的值只有一步而已，那就是识别=>反射=>读属性。

通过上述表达式可以看出，一个表达式中有两个关键元素，即：操作符（operator）和操作数(operand).

对于操作符而言，常见是分为一元和二元的，对于二元操作符自然是有2个操作数的，不同操作数之间类型的不同也导致了结果的输出的不同。

还要考虑操作符的优先级顺序，因为在表达式中，优先级决定了谁优先计算，这步的实现直接导致了表达式表达意义的对与错。

所以在对一段表达式做计算前，必须要完成三个步骤

1.合法性检测=>a.是否包含未完全匹配的小括号.异常反馈及处理。

                      b.是否出现无意义的参量或者表达式

                      c.非法操作符或非法操作数

2.表达式分析=> a.是否包含有中文表达式（如果有则要进行反射取值）

             b.操作符的可操作类型，操作元个数

3.操作数的类型，类型的溢出=>字符串，数值等类型的比较。

STEP1：计算单元

既然本文是写表达式识别，那么就要先从表达式存储结构开始，由下图可以看出事例表达式即将被分离成若干计算单元：

 

 

由上图可以看出，最终此表达式被简化了，那么这些操作数和操作符，都以树的结构被构建出来，因此创建了一个FCNNodes的类来存储如此的计算小单元。

public class FCNNodes
   {
       #region 构造函数
       public FCNNodes() { }

       public FCNNodes(FCNOprand oprand, FCNNodes oprn1, FCNNodes oprn2, int ndeep) : this(){……}

       public FCNNodes(FCNOprand oprand, FCNNodes oprn1, FCNNodes oprn2) : this(oprand, oprn1, oprn2, 0) {……}

       public FCNNodes(FCNOprand oprand, object value) : this() {……  }
       #endregion

       #region 属性定义
       /// <summary>
       /// 运算符
       /// </summary>
       public FCNOprand Oprand{get; set;}
       /// <summary>
       /// 子计算节点1
       /// </summary>
       public FCNNodes Oprn1 {set;get;}
       /// <summary>
       /// 子计算节点2
       /// </summary>
       public FCNNodes Oprn2 {get;set;}
       private object _value= null;
       /// <summary>
       /// 本计算结点内的计算结果
       /// </summary>
       public object Value
       {
           set { _value = value; }
           get
           {
               if (_value != null)
               {
                   return _value;
               }
               else
               {

                   /**
                    * 根据节点Oprand去找出对应的运算方法。
                    */
                   //计算式子
                   if ((this.Oprand & FCNOprand.CALCULATER) != 0)
                   {
                       FCNCalculater fcnc = new FCNCalculater();
                       _value = fcnc.Calculater(this);
                   }
                   //判断式子
                   if ((this.Oprand & FCNOprand.JUDAGER) != 0)
                   {
                       FCNJudager fcnj = new FCNJudager();
                       _value = fcnj.Judager(this);
                   }
                   return _value;
               }
           }
       }
       /// <summary>
       /// 计算式深度
       /// </summary>
       public int nDeep{set;get;}
       #endregion
   }

 

STEP2：读取计算表达式

全匹配,从最内部开始，根据正则表达式，取一个表达式中最内部的表达式最后得到最简表达式。

最简表达式的计算符号识别，有很多的算法，此处只作为引子，会专门用一节去说明这个。
STEP3：如何计算

一个节点计算单元其目的就是为了算出Value值，所以外部只要访问这个Value自然就可以计算出来。在Value的内部，使用Oprand取找出对应的方法，Oprand是一个操作符枚举[Flags]。

到现在为止，分为两个计算类别：数值计算及逻辑计算。

数值计算的有:+-*/%

逻辑计算的有:==,>,<,!=,&&,||,>=,<=

这里只例举了一些常用的，当然你也可以自定义一些你认为比较有性格的计算符号-_-，它们的计算方式都被定义在FCNCalculater 和FCNJudager。(其实当我写出来后，我发现这种组织方法并不是很好的，之后会有一些说明。)

现在用FCNJudager为例子:

 

public class FCNJudager
   {
       public FCNJudager()
       {

       }
       /// <summary>
       /// 判断访问器
       /// </summary>
       /// <param name="fcnn"></param>
       /// <returns></returns>
       public virtual bool Judager(FCNNodes fcnn)
       {
           /**
            * 1.找出两者共有类型，如:oprn1是int型,oprn2是string型,那么返回string。
            */
           bool result = false;

           switch (fcnn.Oprand)
           {
               case FCNOprand.Equals:
                   {
                       #region Equals Logic
                       result = jageEqual(fcnn);
                       #endregion
                   }
                   break;
               case FCNOprand.Bigthan:
                   {
                       #region Bigthan Logic
                       result = BigSmallThan(fcnn.Oprn1.Value, fcnn.Oprn2.Value);
                       #endregion
                   }
                   break;
               case FCNOprand.Smallthan:
                   {
                       #region Smallthan Logic
                       result = !BigSmallThan(fcnn.Oprn2.Value, fcnn.Oprn1.Value);
                       #endregion
                   }
                   break;
               case FCNOprand.NoEquals:
                   {
                       #region NoEquals Logic
                       result = !jageEqual(fcnn);
                       #endregion
                   }
                   break;
               case FCNOprand.AND:
                   {
                       #region AND Logic
                       //True && False
                       if (FCNTypeChecker.Checker<bool>(fcnn.Oprn1.Value)
                           && FCNTypeChecker.Checker<bool>(fcnn.Oprn2.Value))
                       {
                           result = bool.Parse(fcnn.Oprn1.Value.ToString()) && bool.Parse(fcnn.Oprn2.Value.ToString());
                       }
                       #endregion
                   }
                   break;
               case FCNOprand.OR:
                   {
                       #region OR Logic
                       //True || False
                       if (FCNTypeChecker.Checker<bool>(fcnn.Oprn1.Value)
                           && FCNTypeChecker.Checker<bool>(fcnn.Oprn2.Value))
                       {
                           result = bool.Parse(fcnn.Oprn1.Value.ToString()) || bool.Parse(fcnn.Oprn2.Value.ToString());
                       }
                       #endregion
                   }
                   break;
               case FCNOprand.BigthanEquals:
                   {
                       #region BigthanEquals Logic
                       if (jageEqual(fcnn) || BigSmallThan(fcnn.Oprn1.Value, fcnn.Oprn2.Value))
                       {
                           result = true;
                       }
                       #endregion
                   }
                   break;
               case FCNOprand.SmallthanEquals:
                   {
                       #region SmallthanEquals Logic
                       if (jageEqual(fcnn) || !BigSmallThan(fcnn.Oprn2.Value, fcnn.Oprn1.Value))
                       {
                           result = true;
                       }
                       #endregion
                   }
                   break;
           }
           return result;
       }
       /// <summary>
       /// 大小比较
       /// </summary>
       /// <param name="value1"></param>
       /// <param name="value2"></param>
       /// <returns></returns>
       private static bool BigSmallThan(object value1, object value2)
       {
           bool bresult = false;
           //int -> datetime -> string
           if (FCNTypeChecker.Checker<int>(value1.ToString())
               && FCNTypeChecker.Checker<int>(value2.ToString()))
           {
               bresult = int.Parse(value1.ToString()) > int.Parse(value2.ToString());
           }
           if (FCNTypeChecker.Checker<long>(value1.ToString())
               && FCNTypeChecker.Checker<long>(value2.ToString()))
           {
               bresult = long.Parse(value1.ToString()) > long.Parse(value2.ToString());
           }
           if (FCNTypeChecker.Checker<DateTime>(value1.ToString())
               && FCNTypeChecker.Checker<DateTime>(value2.ToString()))
           {
               bresult = (DateTime.Parse(value1.ToString()).CompareTo(DateTime.Parse(value2.ToString())) == 1);
           }

           if (value1.ToString().CompareTo(value2.ToString()) == 1)
           {
               bresult = true;
           }
           return bresult;
       }
       /// <summary>
       /// 相等判断
       /// </summary>
       /// <param name="fcnn"></param>
       /// <returns></returns>
       private bool jageEqual(FCNNodes fcnn)
       {
           bool bresult = false;
           if (FCNTypeChecker.Checker<int>(fcnn.Oprn1.Value.ToString())
               && FCNTypeChecker.Checker<int>(fcnn.Oprn2.Value.ToString()))
           {
               bresult = int.Parse(fcnn.Oprn1.Value.ToString()) == int.Parse(fcnn.Oprn2.Value.ToString());
           }
           if (FCNTypeChecker.Checker<long>(fcnn.Oprn1.Value.ToString())
               && FCNTypeChecker.Checker<long>(fcnn.Oprn2.Value.ToString()))
           {
               bresult = long.Parse(fcnn.Oprn1.Value.ToString()) == long.Parse(fcnn.Oprn2.Value.ToString());
           }
           if (fcnn.Oprn1.Value.ToString().Equals(fcnn.Oprn2.Value.ToString()))
           {
               bresult = true;
           }
           return bresult;
       }
   }

 

在判断式中是以这样的步骤进行的:

1.首先根据节点单元中的操作符找到对应的操作逻辑。

2.在操作逻辑中，获取节点单元的两个子节点的Value。

3.判断返回的Value是何种类型。

 

外话

对于第三点特别说明一下，此处给的事例是很简单的，主要是先判断是否为int，然后在判断是否为long，最后才是string.（当然在这里考虑的方面依然是很幼稚的！）

如果是整型会有溢出，如果是一个是int，一个是string，那么就以string返回，等等这些都需要做Check，而如果在这个地方把所有的情况全部例举全，那是何等的壮观啊！！

此时，我想这些操作符的特性都限定在一个类里面，然后用一个操作符的集合去管理这些类。