我希望能够找到一个单词的第一个字母与诸如“ ABC”之类的组中的一个字母之间的匹配。在伪代码中，这可能类似于：
case Process(word) =>
word.firstLetter match {
case([a-c][A-C]) =>
case _ =>
}
}
但是我该如何在Scala中而不是Java中获取第一个字母？如何正确表达正则表达式？是否可以在case class内执行此操作？
您可以这样做，因为正则表达式定义了提取器，但是您需要首先定义正则表达式模式。我无权使用Scala REPL进行测试，但类似的东西应该可以工作。
val Pattern = "([a-cA-C])".r
word.firstLetter match {
case Pattern(c) => c bound to capture group here
case _ =>
}
从版本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的可能性的一个令人印象深刻的示例，显示在博客文章Introduction to Type Dynamic：
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)$`.Regexp(lastChar))) =>
println(s"Match! $fn ...$lastChar")
case _ => println("nope")
}
}
正如delnan指出的那样，Scala中的match关键字与正则表达式无关。要找出字符串是否与正则表达式匹配，可以使用String.matches方法。要确定字符串是以小写还是大写的a，b或c开头，则正则表达式如下所示：
word.matches("[a-cA-C].*")
您可以将此正则表达式读为“字符a，b，c，A，B或C之一，后跟任何字符”（.表示“任何字符”，*表示“零次或多次”，因此“。*”是任何字符串）。
[在Andrew's answer上稍加扩展：正则表达式定义提取器的事实可以很好地使用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.
}
String.matches是进行正则表达式意义上的模式匹配的方法。
但是作为方便，实际的Scala代码中的word.firstLetter看起来像：
word(0)
Scala将字符串视为Char的序列，因此，如果出于某种原因想要显式获取String的第一个字符并进行匹配，则可以使用类似以下内容的方式：
"Cat"(0).toString.matches("[a-cA-C]")
res10: Boolean = true
我不建议将其作为进行正则表达式模式匹配的一般方法，但这与您建议的首先找到String的第一个字符，然后将其与正则表达式匹配的方法是一致的。
编辑：要明确的是，我这样做的方式是，正如其他人所说的：
"Cat".matches("^[a-cA-C].*")
res14: Boolean = true
只是想显示一个尽可能接近初始伪代码的示例。干杯！
请注意，@ AndrewMyers的答案中的方法将entire字符串与正则表达式匹配，其效果是使用^和$将正则表达式锚定在字符串的两端。示例：
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
首先，我们应该知道可以单独使用正则表达式。这是一个例子：
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