regex - scala中的表达式评估器(可能带有占位符？)

Question

我正在从我的配置文件中读取类似的内容:

metric1.critical = "<2000 || >20000"
metric1.okay = "=1"
metric1.warning = "<=3000"
metric2.okay = ">0.9 && < 1.1 "
metric3.warning ="( >0.9 && <1.5) || (<500 &&>200)"

我有一个

metric1.value =  //have some value

我的目标是基本上评估

    if(metric1.value<2000 || metric1.value > 20000)
     metric1.setAlert("critical");
    else if(metric1.value=1)
     metric.setAlert("okay");
    //and so on

我不太擅长正则表达式，所以我会尽量不使用它。我在 Scala 中编码，想知道是否有任何现有的库可以帮助解决这个问题。也许我需要放置占位符来填补空白，然后评估表达式？但是如何以最有效的方式评估表达式并减少开销？

编辑:
在 java 中，我们如何拥有表达式评估器库，我希望我能为我的代码找到类似的东西。也许我可以在配置文件中添加占位符，例如“？”这些来代替我的 metric1.value (读取变量)然后使用评估器？
或者
有人可以为此建议一个好的正则表达式吗？
提前致谢!

Answer 1

这听起来像是您想使用解析器组合器库定义自己的语法。

Scala 类库中内置了一个解析器组合器。由于 scala 库已经模块化，它现在是一个单独的项目，位于 https://github.com/scala/scala-parser-combinators .

更新:每个寻找在概念上类似于 scala-parser-combinators 的解析器组合库的人都应该看看 fastparse .它非常快，并且不使用宏。所以它可以作为 scala-parser-combinators 的替代品。

Programming in Scala 中有一些关于如何使用它的示例，第 33 章，“组合子解析”。

这里有一些语法、ast 和 evaluator 可以帮助您入门。这遗漏了很多东西，例如空格处理、运算符优先级等。您也不应该使用字符串来编码不同的比较运算符。但我认为通过这一章和Scala编程的章节，你应该能够想出适合你需求的东西。

import scala.util.parsing.combinator.{JavaTokenParsers, PackratParsers}

sealed abstract class AST
sealed abstract class BooleanExpression extends AST
case class BooleanOperation(op: String, lhs: BooleanExpression, rhs:BooleanExpression) extends BooleanExpression
case class Comparison(op:String, rhs:Constant) extends BooleanExpression
case class Constant(value: Double) extends AST

object ConditionParser extends JavaTokenParsers with PackratParsers {

  val booleanOperator : PackratParser[String] = literal("||") | literal("&&")
  val comparisonOperator : PackratParser[String] = literal("<=") | literal(">=") | literal("==") | literal("!=") | literal("<") | literal(">")
  val constant : PackratParser[Constant] = floatingPointNumber.^^ { x => Constant(x.toDouble) }
  val comparison : PackratParser[Comparison] = (comparisonOperator ~ constant) ^^ { case op ~ rhs => Comparison(op, rhs) }
  lazy val p1 : PackratParser[BooleanExpression] = booleanOperation | comparison
  val booleanOperation = (p1 ~ booleanOperator ~ p1) ^^ { case lhs ~ op ~ rhs => BooleanOperation(op, lhs, rhs) }
}

object Evaluator {

  def evaluate(expression:BooleanExpression, value:Double) : Boolean = expression match {
    case Comparison("<=", Constant(c)) => value <= c
    case Comparison(">=", Constant(c)) => value >= c
    case Comparison("==", Constant(c)) => value == c
    case Comparison("!=", Constant(c)) => value != c
    case Comparison("<", Constant(c)) => value < c
    case Comparison(">", Constant(c)) => value > c
    case BooleanOperation("||", a, b) => evaluate(a, value) || evaluate(b, value)
    case BooleanOperation("&&", a, b) => evaluate(a, value) && evaluate(b, value)
  }
}

object Test extends App {

  def parse(text:String) : BooleanExpression = ConditionParser.parseAll(ConditionParser.p1, text).get

  val texts = Seq(
    "<2000",
    "<2000||>20000",
    "==1",
    "<=3000",
    ">0.9&&<1.1")

  val xs = Seq(0.0, 1.0, 100000.0)

  for {
    text <- texts
    expression = parse(text)
    x <- xs
    result = Evaluator.evaluate(expression, x)
  } {
    println(s"$text $expression $x $result")
  }
}