Corrispondenza con un'espressione regolare in Scala

Question

Corrispondenza abbastanza frequente con le espressioni regolari. In Java:..

java.util.regex.Pattern.compile ("\ w +") matcher ("this_is") partite

Ouch. Scala ha molte alternative.

1. "\\w+".r.pattern.matcher("this_is").matches
2. "this_is".matches("\\w+")
3. "\\w+".r unapplySeq "this_is" isDefined
4. val R = "\\w+".r; "this_is" match { case R() => true; case _ => false}

Il primo è altrettanto pesante come il codice Java.

Il problema con il secondo è che non è possibile fornire un modello compilato ("this_is".matches("\\w+".r")). (Questo sembra essere un anti-pattern poiché quasi ogni volta che c'è un metodo che prende una regex per compilare c'è un sovraccarico che prende una regex).

Il problema con il terzo è che abusa di unapplySeq e quindi è criptico.

Il quarto è grande quando si decompongono parti di un'espressione regolare, ma è troppo pesante quando si desidera solo un risultato booleano.

Mi manca un modo semplice per verificare le corrispondenze con un'espressione regolare? C'è un motivo per cui String#matches(regex: Regex): Boolean non è definito? In effetti, dove è definito String#matches(uncompiled: String): Boolean?

Answer 1

è possibile definire un modello come questo:

scala> val Email = """(\w+)@([\w\.]+)""".r 

findFirstIn tornerà Some[String] se corrisponde o altrimenti None.

scala> Email.findFirstIn("test@example.com") 
res1: Option[String] = Some(test@example.com) 

scala> Email.findFirstIn("test") 
rest2: Option[String] = None 

Si potrebbe anche estrarre:

scala> val Email(name, domain) = "test@example.com" 
name: String = test 
domain: String = example.com 

Infine, è anche possibile utilizzare convenzionale metodo String.matches (e anche riciclare la precedenza definito Email Regexp:.

scala> "david@example.com".matches(Email.toString) 
res6: Boolean = true 

Spero che questo vi aiuterà

Answer 2

Ho creato un piccolo pattern "Pimp my Library" per quel problema Forse ti aiuterà.

import util.matching.Regex 

object RegexUtils { 
    class RichRegex(self: Regex) { 
    def =~(s: String) = self.pattern.matcher(s).matches 
    } 
    implicit def regexToRichRegex(r: Regex) = new RichRegex(r) 
} 

Esempio di utilizzo

scala> import RegexUtils._ 
scala> """\w+""".r =~ "foo" 
res12: Boolean = true 

Answer 3

Attualmente (agosto 2014, Scala 2.11) @ risposta di David dice la norma.

Tuttavia, sembra che l'interpolatore di stringa r."..." possa essere d'aiuto per questo.Vedo How to pattern match using regular expression in Scala?

Answer 4

Io di solito uso

val regex = "...".r 
if (regex.findFirstIn(text).isDefined) ... 

ma credo che sia abbastanza imbarazzante.