java - 如果可能的话，如何使用正则表达式执行字符串中具有逻辑运算符的表达式

Question

我从数据库中获取表达式，如“Category==BWFULL && Channel==ANDROID && ver > 200”。现在我正在从用户那里获取任何类别、 channel 和版本值的输入。我必须使用上面给出的表达式来验证该输入。我可以用多个 if else 条件来做到这一点。但我不想那样做。有没有最好的方法来评估这个表达式。

此外，我无法使用正则表达式，因为不知道如何处理 ver>200。需要澄清的是，!=、>=、<=、==、>、< 存在于表达式中，并且这些类别、 channel 和版本的值是动态的。

实际上我不想为此使用第三方库。我认为 ScriptManager 可以执行，但表达式必须是“Category==\”BWFULL\” && Channel==\“ANDROID\” && ver > 200”。

ScriptEngineManager manager = new ScriptEngineManager();
       ScriptEngine engine = manager.getEngineByName("js");
       engine.put("Category", "BWFULL");
       engine.put("ver",90);
       engine.put("Channel","ANDROID");

但是为此我必须在我想跳过的表达式中放入引号。它也需要一些时间来评估。那么有没有其他解决办法。

现在我正在使用正则表达式，例如

Pattern.matches("([a-zA-Z]+ *== *NMW *&&)( *[a-zA-Z]+ *== *android +&&)( *[a-zA-Z]+ *== *nitrogen)", "walletcategory  ==  NMW && channel  ==android && ghb == nitrogen")

但问题仍然是 value > 200 或 order 。在上面的正则表达式中，表达式的顺序是静态的，但我希望它以任何顺序。

现在花了一些努力，我想出了使用正则表达式的解决方案。

public class Main {


    public static void main(String[] args) {


//    
      String str = "walletcategory == NMW && asdfs == airtel && ghb == nitrogen && val >= 200";
        Pattern regex = Pattern.compile("[(>=)(==)(!=)(<=)]{2}|[(<)(>)]");

        evaluateTimeForForLoop(str, regex);

    }

    private static void evaluateTimeForForLoop(String str, Pattern regex) {
        long startTime = System.nanoTime();
      String[] strArr = str.split("&&");
      int len = strArr.length;
      String input[] = {"NMW","airtel","nitrogen"};
      for(int i = 0; i < len-1 ;i++) {
          String opee = strArr[i];
          String op = extractOperatorFromString(opee,regex);
          if(op != null) {
              String right = opee.substring(opee.indexOf(op)+op.length(),opee.length()).trim();
              System.out.println(evaluate(input[i], op, right));
          }

      }
      String str3 = strArr[3];
      String operator = extractOperatorFromString(str3,regex);
      if(operator != null) {
          String right = str3.substring(str3.indexOf(operator)+operator.length(),str3.length()).trim();
          System.out.println(evaluate(100, operator, Integer.parseInt(right)));
      }
        long endTime = System.nanoTime();
          System.out.println(endTime - startTime);
    }



    private static String extractOperatorFromString(String str, Pattern regex) {
        try {
            Matcher regexMatcher = regex.matcher(str);
             boolean bool = regexMatcher.matches();
            if (regexMatcher.find()) {
               return regexMatcher.group();
            } 
        } catch (PatternSyntaxException ex) {
            // Syntax error in the regular expression
        }
        return null;
    }   

    private static boolean evaluate(int left, String op, int right)
    {
            switch (op)
            {
            case "==":
                    return left == right;
            case ">":
                    return left > right;
            case "<":
                    return left < right;
            case "<=":
                    return left <= right;
            case ">=":
                    return left >= right;
            case "!=":
                    return left != right;
            default:
                    System.err.println("ERROR: Operator type not recognized.");
                    return false;
            }
    }
    private static boolean evaluate(String left, String op, String right)
    {
            switch (op)
            {
            case "==":
                    return left.equals(right);
            case "!=":
                    return !left.equals(right);
            default:
                    System.err.println("ERROR: Operator type not recognized.");
                    return false;
            }
    }

}

但如果有更好的方法使用正则表达式来执行此操作，仍在等待响应。

Answer 1

这三个选项是否是静态的？如果您始终有类别、 channel 和版本，则只需将数据库修改为:

requiredCategory
requiredChannel
requiredMinimalVersion (due to > 200)

然后根据用户参数简单地评估这些。但我不想像您那样将任何约束存储在一个字符串中。