如何在 Scala 中使用正则表达式进行模式匹配？

Question

我希望能够找到单词的第一个字母与组中的一个字母（例如“ABC”）之间的匹配项。在伪代码中，这可能看起来像：

case Process(word) =>
   word.firstLetter match {
      case([a-c][A-C]) =>
      case _ =>
   }
}

但是如何在 Scala 而不是 Java 中获取第一个字母？如何正确表达正则表达式？是否可以在 案例类 中执行此操作？

Answer 1

稍微扩展一下 Andrew 的答案：表达式定义提取器可用于使用 Scala 的模式匹配很好地分​​解正则表达式匹配的子字符串，例如：

val Process = """([a-cA-C])([^\s]+)""".r // define first, rest is non-space
for (p <- Process findAllIn "aha bah Cah dah") p match {
  case Process("b", _) => println("first: 'a', some rest")
  case Process(_, rest) => println("some first, rest: " + rest)
  // etc.
}

Answer 2

请注意，@AndrewMyers 的答案中的方法将 整个 字符串与正则表达式匹配，其效果是使用 ^ 和 将正则表达式锚定在字符串的两端>$。示例：

scala> val MY_RE = "(foo|bar).*".r
MY_RE: scala.util.matching.Regex = (foo|bar).*

scala> val result = "foo123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = foo

scala> val result = "baz123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = No match

scala> val result = "abcfoo123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = No match

末尾没有 .*：

scala> val MY_RE2 = "(foo|bar)".r
MY_RE2: scala.util.matching.Regex = (foo|bar)

scala> val result = "foo123" match { case MY_RE2(m) => m; case _ => "No match" }
result: String = No match

Answer 3

String.matches 是在正则表达式意义上进行模式匹配的方法。

但顺便说一句，真正的 Scala 代码中的 word.firstLetter 看起来像：

word(0)

Scala 将字符串视为 Char 的序列，因此如果出于某种原因你想显式获取字符串的第一个字符并匹配它，你可以使用类似的东西这：

"Cat"(0).toString.matches("[a-cA-C]")
res10: Boolean = true

我并不建议将此作为进行正则表达式模式匹配的一般方法，但它符合您建议的方法，即首先找到字符串的第一个字符，然后将其与正则表达式进行匹配。

编辑：
需要明确的是，正如其他人所说，我这样做的方式是：

"Cat".matches("^[a-cA-C].*")
res14: Boolean = true

只是想展示一个尽可能接近您的初始伪代码的示例。干杯!

Answer 4

首先我们应该知道正则表达式是可以单独使用的。这是一个例子：

import scala.util.matching.Regex
val pattern = "Scala".r // <=> val pattern = new Regex("Scala")
val str = "Scala is very cool"
val result = pattern findFirstIn str
result match {
  case Some(v) => println(v)
  case _ =>
} // output: Scala

其次，我们应该注意到，将正则表达式与模式匹配相结合将非常强大。这是一个简单的例子。

val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
"2014-11-20" match {
  case date(year, month, day) => "hello"
} // output: hello

其实正则表达式本身就已经很强大了；我们唯一需要做的就是通过Scala 让它变得更加强大。以下是 Scala 文档中的更多示例： http://www.scala-lang.org/files/archive/api/current/index.html#scala.util.matching.Regex

Answer 5

您可以这样做，因为正则表达式定义了提取器，但您需要首先定义正则表达式模式。我无法访问 Scala REPL 来测试它，但类似的东西应该可以工作。

val Pattern = "([a-cA-C])".r
word.firstLetter match {
   case Pattern(c) => c bound to capture group here
   case _ =>
}

无捕获组

仅检查 Regex< /a> 匹配，忽略任何组，
使用序列通配符：

val date = "[0-9]{4}-[0-9]{2}-[0-9]{2}".r
"2004-01-20" match {
    case date(_*) => "It's a date!"
}

子字符串匹配

在模式匹配中，Regex 通常匹配整个输入。
但是，未锚定的 Regex 会在任何地方找到该模式
在输入中：

val date = "([0-9]{4}-[0-9]{2}-[0-9]{2})".r.unanchored
"The date is 2004-01-20 today" match {
    case date(d) => s"Found a date $d!"
}

Answer 6

从版本 2.10 开始，可以使用 Scala 的字符串插值功能：

implicit class RegexOps(sc: StringContext) {
  def r = new util.matching.Regex(sc.parts.mkString, sc.parts.tail.map(_ => "x"): _*)
}

scala> "123" match { case r"\d+" => true case _ => false }
res34: Boolean = true

更好的是可以绑定正则表达式组：

scala> "123" match { case r"(\d+)$d" => d.toInt case _ => 0 }
res36: Int = 123

scala> "10+15" match { case r"(\d\d)${first}\+(\d\d)${second}" => first.toInt+second.toInt case _ => 0 }
res38: Int = 25

还可以设置更详细的绑定机制：

scala> object Doubler { def unapply(s: String) = Some(s.toInt*2) }
defined module Doubler

scala> "10" match { case r"(\d\d)${Doubler(d)}" => d case _ => 0 }
res40: Int = 20

scala> object isPositive { def unapply(s: String) = s.toInt >= 0 }
defined module isPositive

scala> "10" match { case r"(\d\d)${d @ isPositive()}" => d.toInt case _ => 0 }
res56: Int = 10

一个关于 Dynamic 的可能性的令人印象深刻的示例显示在博客文章动态类型简介< /em>:

object T {

  class RegexpExtractor(params: List[String]) {
    def unapplySeq(str: String) =
      params.headOption flatMap (_.r unapplySeq str)
  }

  class StartsWithExtractor(params: List[String]) {
    def unapply(str: String) =
      params.headOption filter (str startsWith _) map (_ => str)
  }

  class MapExtractor(keys: List[String]) {
    def unapplySeq[T](map: Map[String, T]) =
      Some(keys.map(map get _))
  }

  import scala.language.dynamics

  class ExtractorParams(params: List[String]) extends Dynamic {
    val Map = new MapExtractor(params)
    val StartsWith = new StartsWithExtractor(params)
    val Regexp = new RegexpExtractor(params)

    def selectDynamic(name: String) =
      new ExtractorParams(params :+ name)
  }

  object p extends ExtractorParams(Nil)

  Map("firstName" -> "John", "lastName" -> "Doe") match {
    case p.firstName.lastName.Map(
          Some(p.Jo.StartsWith(fn)),
          Some(p.`.*(\\w)
从版本 2.10 开始，可以使用 Scala 的字符串插值功能：
implicit class RegexOps(sc: StringContext) {
  def r = new util.matching.Regex(sc.parts.mkString, sc.parts.tail.map(_ => "x"): _*)
}

scala> "123" match { case r"\d+" => true case _ => false }
res34: Boolean = true

更好的是可以绑定正则表达式组：
scala> "123" match { case r"(\d+)$d" => d.toInt case _ => 0 }
res36: Int = 123

scala> "10+15" match { case r"(\d\d)${first}\+(\d\d)${second}" => first.toInt+second.toInt case _ => 0 }
res38: Int = 25

还可以设置更详细的绑定机制：
scala> object Doubler { def unapply(s: String) = Some(s.toInt*2) }
defined module Doubler

scala> "10" match { case r"(\d\d)${Doubler(d)}" => d case _ => 0 }
res40: Int = 20

scala> object isPositive { def unapply(s: String) = s.toInt >= 0 }
defined module isPositive

scala> "10" match { case r"(\d\d)${d @ isPositive()}" => d.toInt case _ => 0 }
res56: Int = 10

一个关于 Dynamic 的可能性的令人印象深刻的示例显示在博客文章动态类型简介< /em>:
.Regexp(lastChar))) =>
      println(s"Match! $fn ...$lastChar")
    case _ => println("nope")
  }
}

Answer 7

正如 delnan 指出的，Scala 中的 match 关键字与正则表达式无关。要查明字符串是否与正则表达式匹配，可以使用 String.matches 方法。要查明字符串是否以小写或大写的 a、b 或 c 开头，正则表达式将如下所示：

word.matches("[a-cA-C].*")

您可以将此正则表达式读作“后面跟随的字符 a、b、c、A、B 或 C 之一”由任何内容”（. 表示“任何字符”，* 表示“零次或多次”，因此“.*”是任何字符串）。