Scala Language
Reguläre Ausdrücke

Syntax

• re.findAllIn (s: CharSequence): MatchIterator
• re.findAllMatchIn (s: CharSequence): Iterator [Match]
• re.findFirstIn (s: CharSequence): Option [String]
• re.findFirstMatchIn (s: CharSequence): Option [Match]
• re.findPrefixMatchIn (s: CharSequence): Option [Match]
• re.findPrefixOf (s: CharSequence): Option [String]
• re.replaceAllIn (s: CharSequence, Ersetzer: Match => String): String
• re.replaceAllIn (s: CharSequence, Ersetzung: String): String
• re.replaceFirstIn (s: CharSequence, Ersetzung: String): String
• re.replaceSomeIn (s: CharSequence, Ersetzer: Match => Option [String]): String
• re.split (s: CharSequence): Array [String]

Reguläre Ausdrücke deklarieren

Die r Methode, die implizit über scala.collection.immutable.StringOps bereitgestellt wird, erzeugt eine Instanz von scala.util.matching.Regex aus der Betreffzeichenfolge. Die dreifach zitierte Stringsyntax von Scala ist hier hilfreich, da Sie Backslashes nicht wie in Java umgehen müssen:

val r0: Regex = """(\d{4})-(\d${2})-(\d{2})""".r     // :)
val r1: Regex = "(\\d{4})-(\\d{2})-(\\d{2})".r // :(

scala.util.matching.Regex implementiert eine idiomatische API für reguläre Ausdrücke für Scala als Wrapper über java.util.regex.Pattern . Die unterstützte Syntax ist dieselbe. Die Unterstützung von Scala für mehrzeilige String-Literale macht das x Flag jedoch wesentlich nützlicher, indem Kommentare aktiviert und Muster-Whitespace ignoriert werden:

val dateRegex = """(?x:
   (\d{4}) # year
  -(\d{2}) # month
  -(\d{2}) # day
)""".r

Es gibt eine überladene Version von r , def r(names: String*): Regex , mit dem Sie Ihren Pattern-Captures Gruppennamen zuweisen können. Dies ist etwas spröde, da die Namen von den Captures getrennt werden und sollten nur verwendet werden, wenn der reguläre Ausdruck an mehreren Stellen verwendet wird:

"""(\d{4})-(\d{2})-(\d{2})""".r("y", "m", "d").findFirstMatchIn(str) match {
  case Some(matched) =>
    val y = matched.group("y").toInt
    val m = matched.group("m").toInt
    val d = matched.group("d").toInt
    java.time.LocalDate.of(y, m, d)
  case None => ???
}

Wiederholen des Abgleichs eines Musters in einer Zeichenfolge

val re = """\((.*?)\)""".r

val str = "(The)(example)(of)(repeating)(pattern)(in)(a)(single)(string)(I)(had)(some)(trouble)(with)(once)"

re.findAllMatchIn(str).map(_.group(1)).toList
res2: List[String] = List(The, example, of, repeating, pattern, in, a, single, string, I, had, some, trouble, with, once)