ExpressionAnalysis

前段时间写了一个词法分析器，最近在这个词法分析器的基础上写了一个表达式分析器，它可以由词法分析的结果构建出一个DLR表达式树，最终可以编译为一个.NET Method.

定义表达式块：

using System;
using System.Collections.Generic;

namespace Zxf.ExpressionBuilder
{
    public class ExpressionBlock
    {
        public ExpressionBlock(string blockType)
        {
            BlockType = blockType;
            SubBlocks = new List<ExpressionBlock>();
        }

        public ExpressionBlock(string blockType, LexicalBlock lexicalBlock)
        {
            BlockType = blockType;
            LexicalBlock = lexicalBlock;
            SubBlocks = new List<ExpressionBlock>();
        }

        public String BlockType { get; set; }

        public LexicalBlock LexicalBlock { get; set; }

        public List<ExpressionBlock> SubBlocks { get; set; }
    }
}

定义表达式分析的异常类：

using System;

namespace Zxf.ExpressionBuilder
{
    public class ExpressionAnalysisException : ApplicationException
    {
        public ExpressionAnalysisException(string message, LexicalBlock lexicalBlock)
            : base(message)
        {
            LexicalBlock = lexicalBlock;
        }

        public ExpressionAnalysisException(string message, ExpressionBlock expressionBlock)
            : base(message)
        {
            ExpressionBlock = expressionBlock;
        }

        public LexicalBlock LexicalBlock { get; set; }

        public ExpressionBlock ExpressionBlock { get; set; }
    }
}

用来支持各种数据类型间的数据运算：

using System;

namespace Zxf.ExpressionBuilder
{
    public static class DynamicCalculate
    {
        public static bool GreaterThanOrEqual(dynamic a, dynamic b)
        {
            return GetValue(a, b) >= GetValue(b, a);
        }

        public static bool GreaterThan(dynamic a, dynamic b)
        {
            return GetValue(a, b) > GetValue(b, a);
        }

        public static bool LessThanOrEqual(dynamic a, dynamic b)
        {
            return GetValue(a, b) <= GetValue(b, a);
        }

        public static bool LessThan(dynamic a, dynamic b)
        {
            return GetValue(a, b) < GetValue(b, a);
        }

        public static bool Equal(dynamic a, dynamic b)
        {
            if (a is DBNull && b is DBNull)
            {
                return true;
            }
            else if (a is DBNull || b is DBNull)
            {
                return false;
            }
            else
            {
                return GetValue(a, b) == GetValue(b, a);
            }
        }

        public static bool NotEqual(dynamic a, dynamic b)
        {
            if (a is DBNull && b is DBNull)
            {
                return false;
            }
            else if (a is DBNull || b is DBNull)
            {
                return true;
            }
            else
            {
                return GetValue(a, b) != GetValue(b, a);
            }
        }

        public static bool And(dynamic a, dynamic b)
        {
            return a && b;
        }

        public static bool Or(dynamic a, dynamic b)
        {
            return a || b;
        }

        public static Object Add(dynamic a, dynamic b)
        {
            return GetValue(a, b) + GetValue(b, a);
        }

        public static Object Subtract(dynamic a, dynamic b)
        {
            return GetValue(a, b) - GetValue(b, a);
        }

        public static Object Multiply(dynamic a, dynamic b)
        {
            return GetValue(a, b) * GetValue(b, a);
        }

        public static Object Divide(dynamic a, dynamic b)
        {
            return GetValue(a, b) / GetValue(b, a);
        }

        public static Object Modulo(dynamic a, dynamic b)
        {
            return GetValue(a, b) % GetValue(b, a);
        }

        private static dynamic GetValue(dynamic o1, dynamic other)
        {
            if (o1.GetType() == other.GetType())
            {
                return o1;
            }
            else
            {
                if (o1 is string || other is string)
                {
                    return Convert.ToString(o1);
                }
                else if (o1 is ValueType && other is ValueType)
                {
                    if (o1 is decimal || other is decimal)
                    {
                        return (decimal)o1;
                    }
                    else
                    {
                        return o1;
                    }
                }
                else
                {
                    return o1;
                }
            }
        }
    }
}

表达式分析类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using Microsoft.CSharp.RuntimeBinder;

namespace Zxf.ExpressionBuilder
{
    public static class ExpressionAnalysis
    {
        #region Private Memebers

        private static readonly List<List<String>> s_LeveledOperate = new List<List<String>>();

        #endregion

        #region Static Constructor
        static ExpressionAnalysis()
        {
            s_LeveledOperate.Add(new List<String> { "Viariable", "Paras", "Exp", "StringLiteral", "IntegerLiteral", "NULLLiteral", "CharLiteral" });
            s_LeveledOperate.Add(new List<String> { "And", "Or" });
            s_LeveledOperate.Add(new List<String>
                                     {
                                         "GreaterThanOrEqual",
                                         "LessThanOrEqual",
                                         "GreaterThan",
                                         "LessThan",
                                         "Equal",
                                         "NotEqual"
                                     });
            s_LeveledOperate.Add(new List<String> { "Add", "Subtract" });
            s_LeveledOperate.Add(new List<String> { "Multiply", "Divide", "Modulo" });
            s_LeveledOperate.Add(new List<String> { "Dot", "Function", "Index" });
        }
        #endregion

        #region Public Method
        public static TDelegate Analysis<TDelegate>(List<LexicalBlock> lexicalBlocks, Dictionary<string, Type> parametersType)
        {
            Dictionary<string, ParameterExpression> parameterExpressions = parametersType.ToDictionary(
                item => item.Key, item => Expression.Parameter(item.Value));

            ExpressionBlock block = AnalysisBlock(BlockAnalysis("Exp", lexicalBlocks));
            Expression buildExpression = Expression.Convert(BuildExpression(block, parameterExpressions),
                                                            typeof(object));
            Expression<TDelegate> dynamicLambdaExp = Expression.Lambda<TDelegate>(buildExpression, parameterExpressions.Values.ToArray());

            return dynamicLambdaExp.Compile();
        }
        #endregion

        #region Block Process

        private static ExpressionBlock BlockAnalysis(string blockType, List<LexicalBlock> lexicalBlocks)
        {
            var returnBlock = new ExpressionBlock(blockType);

            if (blockType == "Paras")
            {
                int curIndex = 0;
                while (curIndex < lexicalBlocks.Count)
                {
                    int endIndex = GetNotMatchedEndIndex(lexicalBlocks, curIndex, lexicalBlocks.Count);

                    ExpressionBlock paraBlock = BlockAnalysis("Exp", lexicalBlocks.GetRange(curIndex, endIndex - curIndex));
                    returnBlock.SubBlocks.Add(paraBlock);

                    curIndex = endIndex + 1;
                }
            }
            else
            {
                int curIndex = 0;
                while (curIndex < lexicalBlocks.Count)
                {
                    string blockPattern = GetBlockPattern(lexicalBlocks, curIndex, lexicalBlocks.Count);
                    if (blockPattern == "Dot|Viariable|OpenParen")
                    {
                        var funcBlock = new ExpressionBlock("Function") { LexicalBlock = lexicalBlocks[curIndex + 1] };
                        returnBlock.SubBlocks.Add(funcBlock);

                        int endIndex = GetMatchedEndIndex(lexicalBlocks, curIndex + 2, lexicalBlocks.Count);

                        ExpressionBlock parasBlock = BlockAnalysis("Paras", lexicalBlocks.GetRange(curIndex + 3, endIndex - curIndex - 3));
                        returnBlock.SubBlocks.Add(parasBlock);

                        curIndex = endIndex + 1;
                    }
                    else if (blockPattern.StartsWith("OpenBracket"))
                    {
                        var indexBlock = new ExpressionBlock("Index");
                        returnBlock.SubBlocks.Add(indexBlock);

                        int endIndex = GetMatchedEndIndex(lexicalBlocks, curIndex, lexicalBlocks.Count);

                        ExpressionBlock parasBlock = BlockAnalysis("Paras", lexicalBlocks.GetRange(curIndex + 1, endIndex - curIndex - 1));
                        returnBlock.SubBlocks.Add(parasBlock);

                        curIndex = endIndex + 1;
                    }
                    else if (blockPattern.StartsWith("OpenParen"))
                    {
                        int endIndex = GetMatchedEndIndex(lexicalBlocks, curIndex, lexicalBlocks.Count);

                        ExpressionBlock expBlock = BlockAnalysis("Exp", lexicalBlocks.GetRange(curIndex + 1, endIndex - curIndex - 1));
                        returnBlock.SubBlocks.Add(expBlock);

                        curIndex = endIndex + 1;
                    }
                    else
                    {
                        returnBlock.SubBlocks.Add(new ExpressionBlock(lexicalBlocks[curIndex].BlockType, lexicalBlocks[curIndex]));

                        curIndex++;
                    }
                }
            }
            return returnBlock;
        }

        private static String GetBlockPattern(List<LexicalBlock> lexicalBlocks, int start, int end)
        {
            string blockPattern = lexicalBlocks[start].BlockType;

            if (start + 1 < end)
            {
                blockPattern += "|" + lexicalBlocks[start + 1].BlockType;
            }

            if (start + 2 < end)
            {
                blockPattern += "|" + lexicalBlocks[start + 2].BlockType;
            }

            return blockPattern;
        }

        private static Int32 GetMatchedEndIndex(List<LexicalBlock> lexicalBlocks, int start, int end)
        {
            var stack = new Stack<string>();
            for (int i = start; i < end; i++)
            {
                if (lexicalBlocks[i].Text == "("
                    || lexicalBlocks[i].Text == "[")
                {
                    stack.Push(lexicalBlocks[i].Text);
                }
                else if (lexicalBlocks[i].Text == ")"
                         || lexicalBlocks[i].Text == "]")
                {
                    string startFlag = lexicalBlocks[i].Text == ")" ? "(" : "[";
                    if (stack.Peek() == startFlag)
                    {
                        stack.Pop();
                    }
                    else
                    {
                        throw new ExpressionAnalysisException("Missing ')' or ']'", lexicalBlocks[start]);
                    }
                }

                if (stack.Count == 0)
                {
                    return i;
                }
            }
            throw new ExpressionAnalysisException("Missing ')' or ']'", lexicalBlocks[start]);
        }

        private static Int32 GetNotMatchedEndIndex(List<LexicalBlock> lexicalBlocks, int start, int end)
        {
            int curIndex = start;
            while (curIndex < end)
            {
                if (lexicalBlocks[curIndex].Text == "("
                    || lexicalBlocks[curIndex].Text == "[")
                {
                    curIndex = GetMatchedEndIndex(lexicalBlocks, curIndex, lexicalBlocks.Count) + 1;
                }
                else if (lexicalBlocks[curIndex].Text == ",")
                {
                    return curIndex;
                }
                curIndex++;
            }
            return curIndex;
        }

        private static ExpressionBlock AnalysisBlock(ExpressionBlock block)
        {
            //计算分区块
            for (int i = 0; i < block.SubBlocks.Count; i++)
            {
                ExpressionBlock curBlock = block.SubBlocks[i];
                if (curBlock.BlockType == "Paras"
                    || curBlock.BlockType == "Exp"
                    )
                {
                    block.SubBlocks[i] = AnalysisBlock(curBlock);
                }
            }

            //计算表达式块
            if (block.BlockType != "Paras")
            {
                while (block.SubBlocks.Count > 1)
                {
                    var blockStack = new Stack<ExpressionBlock>();
                    for (int i = 0; i < block.SubBlocks.Count; i++)
                    {
                        ExpressionBlock curBlock = block.SubBlocks[i];

                        if (blockStack.Count == 0)
                        {
                            blockStack.Push(curBlock);
                        }
                        else
                        {
                            int curLevel = GetOperateLevel(curBlock);
                            int topLevel = GetOperateLevel(blockStack.Peek());

                            if (curLevel > topLevel)
                            {
                                ExpressionBlock topBlock = blockStack.Pop();
                                int topTopLevel = GetOperateLevel(blockStack.Count == 0 ? null : blockStack.Peek());

                                if (curLevel > topTopLevel)
                                {
                                    curBlock.SubBlocks.Add(topBlock);
                                    blockStack.Push(curBlock);
                                }
                                else if (curLevel == topTopLevel)
                                {
                                    ExpressionBlock topTopBlock = blockStack.Pop();
                                    topTopBlock.SubBlocks.Add(topBlock);

                                    var expBlock = new ExpressionBlock("Exp");
                                    expBlock.SubBlocks.Add(topTopBlock);

                                    curBlock.SubBlocks.Add(expBlock);
                                    blockStack.Push(curBlock);
                                }
                                else
                                {
                                    ExpressionBlock topTopBlock = blockStack.Pop();
                                    topTopBlock.SubBlocks.Add(topBlock);

                                    var expBlock = new ExpressionBlock("Exp");
                                    expBlock.SubBlocks.Add(topTopBlock);

                                    if (blockStack.Count == 0)
                                    {
                                        curBlock.SubBlocks.Add(expBlock);
                                        blockStack.Push(curBlock);
                                    }
                                    else
                                    {
                                        blockStack.Push(expBlock);

                                        blockStack.Push(curBlock);
                                    }
                                }
                            }
                            else if (curLevel < topLevel)
                            {
                                if (block.SubBlocks.Count == i + 1)
                                {
                                    if (blockStack.Peek().SubBlocks.Count == 1)
                                    {
                                        ExpressionBlock topBlock = blockStack.Pop();
                                        topBlock.SubBlocks.Add(curBlock);

                                        var expBlock = new ExpressionBlock("Exp");
                                        expBlock.SubBlocks.Add(topBlock);

                                        blockStack.Push(expBlock);
                                    }
                                    else
                                    {
                                        blockStack.Push(curBlock);
                                    }
                                }
                                else
                                {
                                    blockStack.Push(curBlock);
                                }
                            }
                            else
                            {
                                throw new ExpressionAnalysisException("Not supported LexicalBlock", curBlock.LexicalBlock);
                            }
                        }
                    }

                    block.SubBlocks.Clear();
                    while (blockStack.Count > 0)
                    {
                        block.SubBlocks.Add(blockStack.Pop());
                    }
                    block.SubBlocks.Reverse();
                }
            }

            return block;
        }

        private static Int32 GetOperateLevel(ExpressionBlock block)
        {
            if (block == null) return -1;
            for (int i = 0; i < s_LeveledOperate.Count; i++)
            {
                if (s_LeveledOperate[i].Contains(block.BlockType))
                {
                    return i;
                }
            }
            throw new ExpressionAnalysisException("Not supported LexicalBlock", block.LexicalBlock);
        }

        #endregion

        #region Build Expression

        private static Expression BuildExpression(ExpressionBlock block, Dictionary<string, ParameterExpression> parameterExpressions)
        {
            switch (block.BlockType)
            {
                case "Function":
                    return BuildFunctionExpression(block, parameterExpressions);
                case "Index":
                    return BuildIndexExpression(block, parameterExpressions);
                case "Exp":
                    return BuildExpression(block.SubBlocks[0], parameterExpressions);
                case "CharLiteral":
                case "NULLLiteral":
                case "StringLiteral":
                case "IntegerLiteral":
                    return BuildConstExpression(block);
                case "Dot":
                    return BuildDotExpression(block, parameterExpressions);
                case "GreaterThanOrEqual":
                case "GreaterThan":
                case "LessThanOrEqual":
                case "LessThan":
                case "Equal":
                case "NotEqual":
                case "And":
                case "Or":
                    return BuildLogicExpression(block, parameterExpressions);
                case "Add":
                case "Subtract":
                case "Multiply":
                case "Divide":
                case "Modulo":
                    return BuildAriguExpression(block, parameterExpressions);
                default:
                    return null;
            }
        }

        private static Expression BuildFunctionExpression(ExpressionBlock block,
                                                          Dictionary<string, ParameterExpression> parameterExpressions)
        {
            if (block.SubBlocks.Count != 2)
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[0].BlockType != "Viariable"
                && block.SubBlocks[0].BlockType != "Exp")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[1].BlockType != "Paras")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            var CSharpArgus = new List<CSharpArgumentInfo> { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) };

            var ExpreArgus = new List<Expression>();
            if (block.SubBlocks[0].BlockType == "Viariable")
            {
                if (!parameterExpressions.ContainsKey(block.SubBlocks[0].LexicalBlock.Text))
                {
                    throw new ExpressionAnalysisException("Can not build expression", block);
                }
                ExpreArgus.Add(parameterExpressions[block.SubBlocks[0].LexicalBlock.Text]);
            }
            else
            {
                ExpreArgus.Add(BuildExpression(block.SubBlocks[0], parameterExpressions));
            }

            foreach (ExpressionBlock t in block.SubBlocks[1].SubBlocks)
            {
                CSharpArgus.Add(CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null));
                ExpreArgus.Add(BuildExpression(t, parameterExpressions));
            }

            CallSiteBinder binderInvokeMember = Binder.InvokeMember(CSharpBinderFlags.None, block.LexicalBlock.Text,
                                                                    null, typeof(Object), CSharpArgus.ToArray());
            return Expression.Dynamic(binderInvokeMember, typeof(object), ExpreArgus.ToArray());
        }

        private static Expression BuildIndexExpression(ExpressionBlock block, Dictionary<string, ParameterExpression> parameterExpressions)
        {
            if (block.SubBlocks.Count != 2)
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[0].BlockType != "Viariable"
                && block.SubBlocks[0].BlockType != "Exp")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[1].BlockType != "Paras")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            var CSharpArgus = new List<CSharpArgumentInfo> { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) };

            var ExpreArgus = new List<Expression>();
            if (block.SubBlocks[0].BlockType == "Viariable")
            {
                if (!parameterExpressions.ContainsKey(block.SubBlocks[0].LexicalBlock.Text))
                {
                    throw new ExpressionAnalysisException("Can not build expression", block);
                }
                ExpreArgus.Add(parameterExpressions[block.SubBlocks[0].LexicalBlock.Text]);
            }
            else
            {
                ExpreArgus.Add(BuildExpression(block.SubBlocks[0], parameterExpressions));
            }

            foreach (ExpressionBlock t in block.SubBlocks[1].SubBlocks)
            {
                CSharpArgus.Add(CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null));
                ExpreArgus.Add(BuildExpression(t, parameterExpressions));
            }

            CallSiteBinder binderGetIndex = Binder.GetIndex(CSharpBinderFlags.None, typeof(Object), CSharpArgus.ToArray());
            return Expression.Dynamic(binderGetIndex, typeof(object), ExpreArgus.ToArray());
        }

        private static Expression BuildAriguExpression(ExpressionBlock block, Dictionary<string, ParameterExpression> parameterExpressions)
        {
            if (block.SubBlocks.Count != 2)
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[0].BlockType != "Block"
                && block.SubBlocks[0].BlockType != "Exp"
                && block.SubBlocks[0].BlockType != "CharLiteral"
                && block.SubBlocks[0].BlockType != "NULLLiteral"
                && block.SubBlocks[0].BlockType != "StringLiteral"
                && block.SubBlocks[0].BlockType != "IntegerLiteral")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[1].BlockType != "Block"
                && block.SubBlocks[1].BlockType != "Exp"
                && block.SubBlocks[1].BlockType != "CharLiteral"
                && block.SubBlocks[1].BlockType != "NULLLiteral"
                && block.SubBlocks[1].BlockType != "StringLiteral"
                && block.SubBlocks[1].BlockType != "IntegerLiteral")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            Expression left = BuildExpression(block.SubBlocks[0], parameterExpressions);
            Expression right = BuildExpression(block.SubBlocks[1], parameterExpressions);
            if (left.Type != typeof(Object))
            {
                left = Expression.Convert(left, typeof(object));
            }
            if (right.Type != typeof(Object))
            {
                right = Expression.Convert(right, typeof(object));
            }

            switch (block.BlockType)
            {
                case "Add":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Add"), new[] { left, right });
                case "Subtract":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Subtract"), new[] { left, right });
                case "Multiply":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Multiply"), new[] { left, right });
                case "Divide":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Divide"), new[] { left, right });
                case "Modulo":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Modulo"), new[] { left, right });
                default:
                    return null;
            }
        }

        private static Expression BuildLogicExpression(ExpressionBlock block,
                                                       Dictionary<string, ParameterExpression> parameterExpressions)
        {
            if (block.SubBlocks.Count != 2)
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[0].BlockType != "Block"
                && block.SubBlocks[0].BlockType != "Exp"
                && block.SubBlocks[0].BlockType != "CharLiteral"
                && block.SubBlocks[0].BlockType != "StringLiteral"
                && block.SubBlocks[0].BlockType != "NULLLiteral"
                && block.SubBlocks[0].BlockType != "IntegerLiteral")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[1].BlockType != "Block"
                && block.SubBlocks[1].BlockType != "Exp"
                && block.SubBlocks[1].BlockType != "CharLiteral"
                && block.SubBlocks[1].BlockType != "NULLLiteral"
                && block.SubBlocks[1].BlockType != "StringLiteral"
                && block.SubBlocks[1].BlockType != "IntegerLiteral")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            Expression left = BuildExpression(block.SubBlocks[0], parameterExpressions);
            Expression right = BuildExpression(block.SubBlocks[1], parameterExpressions);
            if (left.Type != typeof(Object))
            {
                left = Expression.Convert(left, typeof(object));
            }
            if (right.Type != typeof(Object))
            {
                right = Expression.Convert(right, typeof(object));
            }

            switch (block.BlockType)
            {
                case "GreaterThanOrEqual":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("GreaterThanOrEqual"), new[] { left, right });
                case "GreaterThan":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("GreaterThan"), new[] { left, right });
                case "LessThanOrEqual":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("LessThanOrEqual"), new[] { left, right });
                case "LessThan":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("LessThan"), new[] { left, right });
                case "Equal":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Equal"), new[] { left, right });
                case "NotEqual":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("NotEqual"), new[] { left, right });
                case "And":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("And"), new[] { left, right });
                case "Or":
                    return Expression.Call(null, typeof(DynamicCalculate).GetMethod("Or"), new[] { left, right });
                default:
                    return null;
            }
        }

        private static Expression BuildConstExpression(ExpressionBlock block)
        {
            switch (block.BlockType)
            {
                case "CharLiteral":
                    return Expression.Constant(block.LexicalBlock.Text[1], typeof(char));
                case "NULLLiteral":
                    return Expression.Constant(DBNull.Value, typeof(DBNull));
                case "StringLiteral":
                    return Expression.Constant(block.LexicalBlock.Text.Substring(1, block.LexicalBlock.Text.Length - 2), typeof(string));
                case "IntegerLiteral":
                    {
                        if (block.LexicalBlock.Text.IndexOf('.') != -1)
                        {
                            Single singleResult;
                            if (Single.TryParse(block.LexicalBlock.Text, out singleResult))
                            {
                                return Expression.Constant(Convert.ToSingle(block.LexicalBlock.Text), typeof(Single));
                            }

                            Double doubleResult;
                            if (Double.TryParse(block.LexicalBlock.Text, out doubleResult))
                            {
                                return Expression.Constant(Convert.ToDouble(block.LexicalBlock.Text), typeof(Double));
                            }

                            Decimal decimalResult;
                            if (Decimal.TryParse(block.LexicalBlock.Text, out decimalResult))
                            {
                                return Expression.Constant(Convert.ToDecimal(block.LexicalBlock.Text), typeof(Decimal));
                            }

                            throw new Exception("Not support number: " + block.LexicalBlock.Text);
                        }
                        else
                        {
                            Int32 int32Result;
                            if (Int32.TryParse(block.LexicalBlock.Text, out int32Result))
                            {
                                return Expression.Constant(Convert.ToInt32(block.LexicalBlock.Text), typeof(Int32));
                            }

                            Int64 int64Result;
                            if (Int64.TryParse(block.LexicalBlock.Text, out int64Result))
                            {
                                return Expression.Constant(Convert.ToInt64(block.LexicalBlock.Text), typeof(Int64));
                            }

                            throw new Exception("Not support number: " + block.LexicalBlock.Text);
                        }
                    }
                  default:
                    return null;
            }
        }

        private static Expression BuildDotExpression(ExpressionBlock block, Dictionary<string, ParameterExpression> parameterExpressions)
        {
            if (block.SubBlocks.Count != 2)
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[0].BlockType != "Viariable"
                && block.SubBlocks[0].BlockType != "Exp")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[1].BlockType != "Viariable")
            {
                throw new ExpressionAnalysisException("Can not build expression", block);
            }

            if (block.SubBlocks[0].BlockType == "Viariable")
            {
                if (!parameterExpressions.ContainsKey(block.SubBlocks[0].LexicalBlock.Text))
                {
                    throw new ExpressionAnalysisException("Can not build expression", block);
                }

                CallSiteBinder binderGetProperty = Binder.GetMember(CSharpBinderFlags.None,
                                                                    block.SubBlocks[1].LexicalBlock.Text,
                                                                    typeof(Object),
                                                                    new[]{CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)});
                return Expression.Dynamic(binderGetProperty, typeof(object), parameterExpressions[block.SubBlocks[0].LexicalBlock.Text]);
            }
            else
            {
                Expression exp = BuildExpression(block.SubBlocks[0], parameterExpressions);

                CallSiteBinder binderGetProperty = Binder.GetMember(CSharpBinderFlags.None,
                                                                    block.SubBlocks[1].LexicalBlock.Text,
                                                                    typeof(Object),
                                                                    new[]{CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)});
                return Expression.Dynamic(binderGetProperty, typeof(object), exp);
            }
        }

        #endregion
    }
}

C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php 课程设计 vue.js
该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
Regular Expression 正则表达式 Aimyon_36 Data Development 正则表达式 redis 数据库
RegularExpression前言1.基本匹配2.元字符2.1点运算符.2.2字符集2.2.1否定字符集2.3重复次数2.3.1*号2.3.2+号2.3.3?号2.4{}号2.5(...)特征标群2.6|或运算符2.7转码特殊字符2.8锚点2.8.1^号2.8.2$号3.简写字符集4.零宽度断言（前后预查）4.1?=...正先行断言4.2?!...负先行断言4.3?Thefatcatsaton
spring security中几大组件的作用和执行顺序阿信在这里 java spring
springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
Vue + Express实现一个表单提交九旬大爷的梦
最近在折腾一个cms系统，用的vue+express，但是就一个表单提交就弄了好久，记录一下。环境：Node10+前端：Vue服务端：Express依赖包：vueexpressaxiosexpress-formidableelement-ui（可选）前言：axiosget请求参数是：paramsaxiospost请求参数是：dataexpressget接受参数是req.queryexpresspo
计算机毕设Node.js+Vue校园易购二手交易平台（程序+LW+部署） Node程序源码强子 vue.js 课程设计 node.js
项目运行环境配置：Node.js最新版+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
计算机毕业设计Node.js+Vue基于Java的医院预约挂号系统(程序+源码+LW+部署) Nodejs洋洋程序 java vue.js 课程设计
该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：Node.js+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可
用前端的语言写后端——Node.js之Express tabzzz 前端前端 node.js express
ExpressExpress是一种流行的模型视图控制器(MVC)Node.js框架，具有快速、极简和灵活的优点，为Web和移动应用程序开发提供了强大的功能集合。最受欢迎的Node.js框架！文章目录Express安装ExpressHelloWorld路由中间件全局中间件应用中间件开放跨域请求几种常用的Express内置中间件函数1.JSON格式数据中间件函数2.静态文件中间件函数3.路由中间件函数
DevExpress WPF中文教程：如何解决排序、过滤遇到的常见问题？（一）界面开发小八哥 wpf devexpress 界面控件 UI开发
DevExpressWPF拥有120+个控件和库，将帮助您交付满足甚至超出企业需求的高性能业务应用程序。通过DevExpressWPF能创建有着强大互动功能的XAML基础应用程序，这些应用程序专注于当代客户的需求和构建未来新一代支持触摸的解决方案。无论是Office办公软件的衍伸产品，还是以数据为中心的商业智能产品，都能通过DevExpressWPF控件来实现。接下来将介绍如何解决DevExpre
DevExpress WPF中文教程：如何解决排序、过滤遇到的常见问题？（二）界面开发小八哥 wpf devexpress 界面控件 UI开发 .net
DevExpressWPF拥有120+个控件和库，将帮助您交付满足甚至超出企业需求的高性能业务应用程序。通过DevExpressWPF能创建有着强大互动功能的XAML基础应用程序，这些应用程序专注于当代客户的需求和构建未来新一代支持触摸的解决方案。无论是Office办公软件的衍伸产品，还是以数据为中心的商业智能产品，都能通过DevExpressWPF控件来实现。接下来将介绍如何解决DevExpre
Java 正则表达式详解艾伦~耶格尔 Java初级 java 正则表达式开发语言学习
正则表达式(RegularExpression，简称regex)是一种强大的文本处理工具，可以用来匹配、搜索和替换文本中的特定模式。在Java中，正则表达式由java.util.regex包提供支持。1.理解正则表达式语法正则表达式使用特殊的字符和符号来定义匹配模式。一些常用的元字符如下：.:匹配任意单个字符*:匹配前面的字符零次或多次+:匹配前面的字符一次或多次?:匹配前面的字符零次或一次[]:
MySQL基础系列:数据统计sum,count 天然玩家 #MySQL MySQL GroupBy found_rows sum count
1数据表数据图1数据表数据2sum功能数据求和统计.序号表达式描述1sum(column_name)所有列的列值相加2sum(expression)统计满足表达式的所有行2.1sum(column_name)查询语句:selectsum(id)fromuserinfosgroupbysex;查询结果:+---------+|sum(id)|+---------+|166||36|+--------
第二章 SQL命令参考-VALUES kygoal
VALUESComputesasetofrows.概要VALUES(expression[,...])[,...][ORDERBYsort_expression[ASC|DESC|USINGoperator][,...]][LIMIT{count|ALL}][OFFSETstart]描述VALUES计算由值表达式指定的行值或一组行值。它通常用于在更大的命令中生成“常量表”，但可以单独使用。当指定多
Oracle用户 Baijinwen DataBase
一：用户用户名密码描述SYS用户指定数据库管理帐户SYSMANOEM_TEMP企业管理器帐户SYSTEM用户指定数据库管理帐户OUTLNOUTLN拥有connect和resource角色FLOWS_FILES该账户拥有oracleapplicationexpress上传的文件MDSYSMDSYSoracle空间数据媒体管理员ORDSYSORDSYSimage管理员EXFSYSEXFSYS表达式过滤
.Net/C#读取CAD软件dwg、dxf数据表实体 WineMonk .NET .net c#
.Net/C#读取CAD软件dwg、dxf数据表实体使用ACadSharp库读取CAD软件dwg数据表实体文末附ACadSharp.dll库文件及源码CadDocReaderusingACadSharp;usingACadSharp.Entities;usingACadSharp.IO;usingCSMath;usingSystem.Text.RegularExpressions;namespac
快递网API 夕夜_如风
快递码"爱沙尼亚":"omniva","AAE快递":"aae","Aramex快递":"aramex","AustraliaPost":"auspost","ADPExpress":"adp","AnPost":"anposten","ACS雅仕快递":"acs","安能物流快递":"annengwuliu","ABF":"abf","ADP":"adp","Aramex":"aramex","
树形列表成员- DevExpress.XtraTreeList.TreeList lihaidomain
多列控制节点(记录)在树形结构中的显示位置。公共构造函数名称描述树形列表初始化一个新的树形列表类实例。公共属性名称描述AccessibilityObject(从System.Windows.Forms.Control的继承)AccessibleDefaultActionDescription(从System.Windows.Forms.Control的继承)AccessibleDescriptio
界面控件DevExpress中文教程：如何PDF图形对象的可见性？界面开发小八哥 pdf devexpress winform 界面控件 WPF ui
DevExpress拥有.NET开发需要的所有平台控件，包含600多个UI控件、报表平台、DevExpressDashboardeXpressApp框架、适用于VisualStudio的CodeRush等一系列辅助工具。屡获大奖的软件开发平台DevExpress近期重要版本v24.1已正式发布，该版本拥有众多新产品和数十个具有高影响力的功能，可为桌面、Web和移动应用提供直观的解决方案，全面解决各
【Python】03.Python 的语句卡戎-caryon Python python 服务器开发语言
一、顺序语句默认情况下,Python的代码执行顺序是按照从上到下的顺序依次执行的二、条件语句2.1条件语句的概念条件语句也叫做分支语句,表示了接下来的逻辑可能有几种走向2.2条件语句的语法Python中使用ifelse关键字表示条件语句2.2.1ififexpression:do_something1do_something2next_something如果expression值为True,则执行
oracle数据库安装和配置：详细教程 liyy614 oracle 人工智能 AI编程数据库 ai编程
安装和配置Oracle数据库是一个较为复杂的过程，需要按照一定的步骤来操作。以下是基于OracleDatabase19c的安装和配置教程，适用于Windows环境。请根据你的具体环境和版本进行适当的调整。1.下载Oracle数据库软件访问Oracle官方网站下载OracleDatabase19cExpressEdition或EnterpriseEdition的安装包。确保下载的版本与你的操作系统兼
linux下全盘查找文件,linux下的查找文件命令find 大表姐绫蛮蛮 linux下全盘查找文件
find1.作用find命令的作用是在目录中搜索文件，它的使用权限是所有用户。2.格式find[path][options][expression]path指定目录路径，系统从这里开始沿着目录树向下查找文件。它是一个路径列表，相互用空格分离，如果不写path，那么默认为当前目录。3.主要参数[options]参数：－depth：使用深度级别的查找过程方式，在某层指定目录中优先查找文件内容。－max
this is incompatible with sql_mode=only_full_group_by解决返回值 mysql sql mysql 数据库
项目场景：有时候，遇到数据库重复数据，需要将数据进行分组，并取出其中一条来展示，这时就需要用到groupby语句。但是，如果mysql是高版本，当执行groupby时，select的字段不属于groupby的字段的话，sql语句就会报错。报错信息如下：Expression#1ofSELECTlistisnotinGROUPBYclauseandcontainsnonaggregatedcolumn
mysql 查询报错 this is incompatible with sql_mode=only_full_group_by Wind Drift mysql sql 数据库
InaggregatedquerywithoutGROUPBY,expression#1ofSELECTlistcontainsnonaggregatedcolumn‘smart_site.tc.company_name’;thisisincompatiblewithsql_mode=only_full_group_by原因：这个错误是由于MySQL的"ONLY_FULL_GROUP_BY"SQL
MySQL解决错误this is incompatible with sql_mode=only_full_group_by… 培根芝士 SQL mysql sql 数据库
在SQL查询语句中加入groupby时报了以下错误：;badSQLgrammar[];nestedexceptionisjava.sql.SQLSyntaxErrorException:Expression#1ofSELECTlistisnotinGROUPBYclauseandcontainsnonaggregatedcolumn'user.varieties.id'whichisnotfunc
新概念英语3册 lesson7-9补充笔记多啦A梦的梦想
Lesson7Mutilatedladies残钞鉴别组【Newwordsandexpressions】生词和短语◆mutilatev.使残缺不全◆chewv.咀嚼◆fiancén.未婚夫◆microwaven.微波，微波炉◆ovenn.炉灶◆safekeepingn.妥善保管◆Newcastlen.纽卡斯尔（英国港市）◆identifyv.鉴别，识别◆spokeswomann.女发言人★mutil
switch case 语句（详细）微微的猪食小窝 1024程序员节 java 面试开发语言
switch介绍switchcase语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。switch语句是非常的基础的知识，掌握起来也不难掌握，语法比较简单。但大部分人基本是知其然，不知其所以然。譬如早期JDK只允许switch的表达式的值int及int类型以下的基本类型，后期的JDK却允许匹配比较字符串、枚举类型语法switchcase语句语法格式如下：switch(expressi
Node.js+Express|Cookie&Session机制理解|实现保存登录状态绍重先
Q&A各个用户的sessionname如何设置用登陆的用户名？用当时时间？req.session.name=req.body.usernamelogout？url列表标签posthtml退出登陆js//登出事件监听varlogout=document.getElementById('logout');logout.onclick=function(){alert('logout');varlogo
Node.js Express 框架 wjs2024 开发语言
Node.jsExpress框架介绍Express是一个快速、开放、极简的Node.jsWeb框架。它为构建Web应用程序和服务提供了一个强大的工具集，使得开发过程更加高效和便捷。Express的设计哲学是提供一个最小的API，让开发者可以轻松地构建自定义的Web应用程序。它被广泛用于构建API和Web服务，并且是许多流行的Node.jsWeb框架的基础。特点1.易于上手Express框架的设计非
javase笔记3----正则表达式芝奥小婷笔记
正则表达式简介正则表达式（RegularExpressions），是一个特殊的字符串，可以对普通的字符串进行校验检测等工作，校验一个字符串是否满足预设的规则。基本语法字符集合[]:表示匹配括号里的任意一个字符。[abc]:匹配a或者b或者c[^abc]:匹配任意一个字符，只要不是a,或b,或c就表示匹配成功[a-z]:表示匹配所有的小写字母的任意一个。[A-Za-z]:表示匹配所有的小写字母和大写
正则表达式语法、运算符优先级 weixin_54668000 mvc
正则表达式(regularexpression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。例如：runoo+b，可以匹配runoob、runooob、runoooooob
二分查找排序算法周凡杨 java 二分查找排序算法折半
一：概念二分查找又称折半查找（折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
java中的BigDecimal bijian1013 java BigDecimal
在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。原文地址：http://blog.csdn.net/ugg/article/de
Shell echo命令详解 daizj echo shell
Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
Oracle DBA 简单操作周凡杨 oracle dba sql
--执行次数多的SQL select sql_text,executions from ( select sql_text,executions from v$sqlarea order by executions desc ) where rownum<81; &nb
画图重绘朱辉辉33 游戏
我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
线程之初体验西蜀石兰线程
一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
linux集群互相免登陆配置林鹤霄 linux
配置ssh免登陆 1、生成秘钥和公钥 ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub 其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密 c
mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html 原因是你使用的InnoDB 表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错. 你可以把这个时间加长,或者优化存储
Socket编程基本的聊天实现。 alleni123 socket
public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
多线程监听器事件模式(一个简单的例子) 百合不是茶线程监听模式
多线程的事件监听器模式监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到创建多线程的事件监听器模式思路: 1, 创建线程并启动,在创建线程的位置设置一个标记 2,创建队
spring InitializingBean接口 bijian1013 java spring
spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle 数据库权限
Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
【Struts2五】Struts2 参数传值 bit1129 struts2
Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
I got serveral questions about auto.offset.reset. This configuration parameter governs how consumer read the message from Kafka when there is no initial offset in ZooKeeper or
nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
nginx gzip压缩配置更多 0 nginx gzip 配置随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
Spring源码学习-JdbcTemplate queryForObject bylijinnan java spring
JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
[冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
看美国那边的气候情况....我有个感觉...是不是要进入小冰期了? 那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段... &nb
js 获取浏览器型号 cuityang js 浏览器
根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head> <meta charset="utf-8" content="text/html"/> <meta name=
C# socks5详解转 dalan_123 socket C#
http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html 这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
运维 Centos问题汇总 dcj3sjt126com 云主机
一、sh 脚本不执行的原因 sh脚本不执行的原因只有2个 1.权限不够 2.sh脚本里路径没写完整。二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom 三、查询连接数
Yii防注入攻击笔记 dcj3sjt126com sql WEB安全 yii
网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
MongoDB简介[一] eksliang mongodb MongoDB简介
MongoDB简介转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用 MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。另外，不
zookeeper windows 入门安装和测试 greemranqq zookeeper 安装分布式
一、序言以下是我对zookeeper 的一些理解： zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。栗子1号：假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
Spring之使用事务缘由(2-注解实现) ihuning spring
Spring事务注解实现 1. 依赖包： 1.1 spring包： spring-beans-4.0.0.RELEASE.jar spring-context-4.0.0.
iOS App Launch Option 啸笑天 option
iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。 launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节。 1、若用户直接
jdk与jre的区别（_） macroli java jvm jdk
简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。 JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。如果安装了JDK，会发同你
Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象 git
$ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
[一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hive hive元数据结构
关键字：Hive元数据、Hive元数据表结构之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。文章最后面，会以一个示例来全面了解一下，
Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。其中Spring 4.1.7主要包含这些更新内容。

ExpressionAnalysis

你可能感兴趣的:(express)