Scala Language
Expresiones regulares

Sintaxis

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

Declarar expresiones regulares

El método r provisto implícitamente a través de scala.collection.immutable.StringOps produce una instancia de scala.util.matching.Regex de la cadena del sujeto. La sintaxis de cadena entre comillas triples de Scala es útil aquí, ya que no tiene que escapar de las barras invertidas como lo haría 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 implementa una API de expresión regular idiomática para Scala como un contenedor sobre java.util.regex.Pattern , y la sintaxis compatible es la misma. Dicho esto, el soporte de Scala para los literales de cadenas de varias líneas hace que la marca x mucho más útil, permitiendo comentarios e ignorando espacios en blanco de patrones:

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

Hay una versión sobrecargada de r , def r(names: String*): Regex que le permite asignar nombres de grupo a sus capturas de patrones. Esto es algo frágil ya que los nombres están disociados de las capturas, y solo deben usarse si la expresión regular se usará en múltiples ubicaciones:

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

Repetir la coincidencia de un patrón en una cadena

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)