Scala Language
Espressioni regolari

Sintassi

• 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): Opzione [Match]
• re.findPrefixOf (s: CharSequence): Option [String]
• re.replaceAllIn (s: CharSequence, replacer: Match => String): String
• re.replaceAllIn (s: CharSequence, replacement: String): String
• re.replaceFirstIn (s: CharSequence, replacement: String): String
• re.replaceSomeIn (s: CharSequence, replacer: Match => Option [String]): String
• re.split (s: CharSequence): Array [String]

Dichiarazione di espressioni regolari

Il metodo r implicitamente fornito tramite scala.collection.immutable.StringOps produce un'istanza di scala.util.matching.Regex dalla stringa dell'oggetto. La sintassi delle stringhe a tre virgolette di Scala è utile qui, dato che non devi sfuggire alle barre rovesciate come faresti in Java:

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

scala.util.matching.Regex implementa un'API di espressioni regolari idiomatiche per Scala come wrapper su java.util.regex.Pattern e la sintassi supportata è la stessa. Detto questo, il supporto di Scala per i letterali di stringa multi-linea rende il flag x sostanzialmente più utile, consentendo commenti e ignorando gli spazi bianchi del pattern:

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

Esiste una versione sovraccaricata di r , def r(names: String*): Regex che consente di assegnare nomi di gruppi alle acquisizioni del modello. Questo è un po 'fragile dato che i nomi sono dissociati dalle acquisizioni e dovrebbero essere utilizzati solo se l'espressione regolare verrà utilizzata in più posizioni:

"""(\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 => ???
}

Ripetizione della corrispondenza di un motivo in una stringa

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)