Scala Language
Expressions régulières

Syntaxe

• re.findAllIn (s: CharSequence): MatchIterator
• re.findAllMatchIn (s: CharSequence): Iterator [Match]
• re.findFirstIn (s: CharSequence): Option [Chaîne]
• re.findFirstMatchIn (s: CharSequence): Option [Match]
• re.findPrefixMatchIn (s: CharSequence): Option [Match]
• re.findPrefixOf (s: CharSequence): Option [Chaîne]
• re.replaceAllIn (s: CharSequence, remplaçant: Match => String): String
• re.replaceAllIn (s: CharSequence, remplacement: String): chaîne
• re.replaceFirstIn (s: CharSequence, replacement: String): String
• re.replaceSomeIn (s: CharSequence, remplacement: Match => Option [String]): String
• re.split (s: CharSequence): Array [String]

Déclaration d'expressions régulières

La méthode r fournie implicitement via scala.collection.immutable.StringOps génère une instance de scala.util.matching.Regex à partir de la chaîne objet. La syntaxe de chaîne à trois guillemets de Scala est utile ici, car vous n'avez pas à échapper à des barres obliques inverses comme vous le feriez en 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 implémente une API d'expression régulière idiomatique pour Scala en tant que wrapper sur java.util.regex.Pattern , et la syntaxe prise en charge est la même. Cela étant dit, la prise en charge par Scala des littéraux de chaîne multi-lignes rend le fanion x sensiblement plus utile, permettant des commentaires et ignorant les espaces blancs:

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

Il existe une version surchargée de r , def r(names: String*): Regex qui vous permet d'attribuer des noms de groupe à vos captures de motif. Ceci est quelque peu fragile car les noms sont dissociés des captures et ne devraient être utilisés que si l'expression régulière sera utilisée à plusieurs endroits:

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

Répétition de la correspondance d'un motif dans une chaîne

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)