Как сопоставить шаблон, используя регулярное выражение в Scala?

Question

Мне хотелось бы найти совпадение между первой буквой слова и одной из букв в группе, такой как «ABC». В псевдокоде, это может выглядеть примерно так:

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

Но как я хватаю первую букву в Scala вместо Java? Как правильно выразить регулярное выражение? Возможно ли это сделать в пределах case class?

Answer 1

Вы можете сделать это, потому что регулярные выражения определяют экстракторы, но вам нужно сначала определить шаблон регулярного выражения. У меня нет доступа к Scala REPL, чтобы проверить это, но что-то вроде этого должно работать.

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

Answer 2

Как указал Дельнан, ключевое слово match в Scala не имеет ничего общего с регулярными выражениями. Чтобы узнать, соответствует ли строка регулярному выражению, вы можете использовать метод String.matches. Для того, чтобы выяснить, начинается ли строка с а, б или в нижнем или верхнем регистре, регулярное выражение будет выглядеть следующим образом:

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

Вы можете прочитать это регулярное выражение, как «один из символов а, Ь, с , A, B или C, за которым следует что-либо »(. означает« любой символ »и * означает« ноль или более раз », поэтому«. * »- любая строка).

Answer 3

String.matches - способ сделать сопоставление образцов в смысле регулярного выражения.

Но как удобно в сторону, word.firstLetter в реальном коде Scala выглядит следующим образом:

word(0) 

Scala обрабатывает строки как последовательность Char, так что если по какой-то причине вы хотите явно получить первый символ струнные и сравнить его, вы могли бы использовать что-то вроде этого:

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

Я не предлагаю это как общий способ сделать регулярное выражение сопоставления с образцом, но в соответствии с предлагаемым вашим подходом к первому найти первый символ строки и затем сопоставить ее с регулярным выражением.

EDIT: Чтобы быть ясно, как я хотел бы сделать это, как говорят другие:

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

Просто хотел показать пример как можно ближе к вашему начальному псевдокоду. Ура!

Answer 4

Чтобы немного расширить на 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. 
} 

Answer 5

Начиная с версии 2.10, можно использовать в Scala функцию интерполяции строк:

implicit class Regex(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") 
    } 
} 

Answer 6

Обратите внимание, что подход с @ ответом 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 7

Во-первых, мы должны знать, что регулярное выражение может использоваться отдельно. Вот пример:

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