Làm thế nào để khớp mẫu bằng cách sử dụng biểu thức chính quy trong Scala?

Tôi muốn có thể tìm thấy sự trùng khớp giữa chữ cái đầu tiên của một từ và một trong các chữ cái trong một nhóm như "ABC". Trong mã giả, điều này có thể trông giống như:

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

Nhưng làm cách nào để lấy chữ cái đầu tiên trong Scala thay vì Java? Làm thế nào để tôi diễn đạt biểu thức chính quy? Có thể làm điều này trong một lớp trường hợp ?

Bạn có thể làm điều này bởi vì các biểu thức chính quy định nghĩa các trình trích xuất nhưng trước tiên bạn cần xác định mẫu biểu thức chính quy. Tôi không có quyền truy cập vào Scala REPL để kiểm tra điều này nhưng một cái gì đó như thế này sẽ hoạt động.

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

Kể từ phiên bản 2.10, người ta có thể sử dụng tính năng nội suy chuỗi của 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

Thậm chí tốt hơn người ta có thể liên kết các nhóm biểu thức chính quy:

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

Cũng có thể thiết lập các cơ chế ràng buộc chi tiết hơn:

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

Một ví dụ ấn tượng về những gì có thể với Dynamicđược hiển thị trong bài đăng trên blog Giới thiệu về Kiểu động :

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")
  }
}

Như del Nam đã chỉ ra, matchtừ khóa trong Scala không liên quan gì đến regexes. Để tìm hiểu xem một chuỗi có khớp với regex hay không, bạn có thể sử dụng String.matchesphương thức này. Để tìm hiểu xem một chuỗi bắt đầu bằng a, b hoặc c trong chữ thường hoặc chữ hoa, biểu thức chính quy sẽ như thế này:

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

Bạn có thể đọc regex này là "một trong các ký tự a, b, c, A, B hoặc C theo sau bởi bất cứ thứ gì" ( .có nghĩa là "bất kỳ ký tự nào" và *có nghĩa là "không hoặc nhiều lần", vì vậy ". *" Là bất kỳ chuỗi nào) .

Để mở rộng một chút về câu trả lời của Andrew : Thực tế là các biểu thức chính quy định nghĩa các trình trích xuất có thể được sử dụng để phân tách các chuỗi con khớp với biểu thức chính xác bằng cách sử dụng khớp mẫu của Scala, ví dụ:

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 là cách thực hiện khớp mẫu theo nghĩa regex.

Nhưng như một tiện ích sang một bên, word.firstLetter trong mã Scala thực sự trông giống như:

word(0)

Scala coi Chuỗi là một chuỗi của Char, vì vậy nếu vì lý do nào đó bạn muốn nhận rõ ràng ký tự đầu tiên của Chuỗi và khớp với chuỗi đó, bạn có thể sử dụng một cái gì đó như thế này:

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

Tôi không đề xuất đây là cách chung để thực hiện khớp mẫu regex, nhưng nó phù hợp với cách tiếp cận được đề xuất của bạn để tìm ký tự đầu tiên của Chuỗi và sau đó khớp với ký tự regex.

EDIT: Để rõ ràng, cách tôi sẽ làm điều này là, như những người khác đã nói:

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

Chỉ muốn hiển thị một ví dụ càng gần càng tốt với mã giả ban đầu của bạn. Chúc mừng!

Lưu ý rằng cách tiếp cận từ câu trả lời của @ AndrewMyer khớp với toàn bộ chuỗi với biểu thức chính quy, với hiệu ứng neo biểu thức chính quy ở cả hai đầu của chuỗi bằng ^và $. Thí dụ:

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

Và không có .*ở cuối:

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

Đầu tiên chúng ta nên biết rằng biểu thức chính quy có thể được sử dụng riêng. Đây là một ví dụ:

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

Thứ hai, chúng ta nên lưu ý rằng việc kết hợp biểu thức chính quy với khớp mẫu sẽ rất mạnh mẽ. Đây là một ví dụ đơn giản.

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

Trong thực tế, bản thân biểu thức chính quy đã rất mạnh mẽ; điều duy nhất chúng ta cần làm là làm cho nó mạnh hơn bởi Scala. Dưới đây là nhiều ví dụ khác trong Tài liệu Scala: http://www.scala-lang.org/files/archive/api/civerse/index.html#scala.util.matching.Regex