Scala Expresiones regulares
Scala, a través de la clase del paquete scala.util.matching,Regexadmite expresiones regulares. El siguiente ejemplo demuestra el uso de expresiones regulares para encontrar palabras.Scala :
Ejemplo
object Test {
def main(args: Array[String]) {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test Some(Scala)
En el ejemplo se usa el método r() de la clase String para construir un objeto Regex.
Luego se usa el método findFirstIn para encontrar la primera coincidencia.
Si necesita ver todas las coincidencias, puede usar el método findAllIn.
Puede usar el método mkString() para concatenar las cadenas de los resultados de coincidencia de la expresión regular, y puede usar la barra vertical (|) para establecer diferentes patrones:
Ejemplo
object Test {
def main(args: Array[String]) {
val pattern = new Regex("(S|s)cala") // La primera letra puede ser S mayúscula o s minúscula
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(",")) // Usar coma , para concatenar los resultados devueltos
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test Scala,scala
Si necesita reemplazar el texto coincidente con una palabra clave específica, puede usarreplaceFirstIn( )método para reemplazar la primera coincidencia, y usarreplaceAllIn( )método para reemplazar todas las coincidencias, como se muestra a continuación:
Ejemplo
def main(args: Array[String]) {
val pattern = "(S|s)cala".r
val str = "Scala is scalable and cool"
println(pattern replaceFirstIn(str, "Java"))
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test Java is scalable and cool
Expresión regular
Las expresiones regulares de Scala heredan las reglas de sintaxis de Java, y Java utiliza en gran parte las reglas del lenguaje Perl.
En la siguiente tabla se muestran algunas reglas comunes de expresiones regulares:
| Expresión | Regla de coincidencia |
|---|---|
| ^ | Coincide con la posición inicial de la cadena de entrada. |
| $ | Coincide con la posición final de la cadena de entrada. |
| . | Coincide con cualquier carácter individual excepto "\r\n". |
| [...] | Conjunto de caracteres. Coincide con cualquiera de los caracteres incluidos. Por ejemplo, "[abc]" coincide con "a" en "plain". |
| [^...] | Conjunto de caracteres negado. Coincide con cualquier carácter no incluido. Por ejemplo, "[^abc]" coincide con "p", "l", "i", "n" en "plain". |
| \\A | Coincide con la posición inicial de la cadena de entrada (sin soporte multilínea) |
| \\z | Final de la cadena (similar a $, pero no afectado por la opción multilínea) |
| \\Z | Final de la cadena o de la línea (no afectado por la opción multilínea) |
| re* | Repite cero o más veces |
| re+ | Repite una o más veces |
| re? | Repite cero o una vez |
| re{ n} | Repite n veces |
| re{ n,} | |
| re{ n, m} | Repite de n a m veces |
| a|b | Coincide con a o b |
| (re) | Coincide con re y captura el texto en un grupo con nombre automático |
| (?: re) | Coincide con re, no captura el texto coincidente ni asigna un número de grupo a este grupo |
| (?> re) | Subexpresión codiciosa |
| \\w | Coincide con letras, dígitos o guion bajo |
| \\W | Coincide con cualquier carácter que no sea letra, dígito, guion bajo o carácter chino |
| \\s | Coincide con cualquier espacio en blanco, equivalente a [\t\n\r\f] |
| \\S | Coincide con cualquier carácter que no sea espacio en blanco |
| \\d | Coincide con dígitos, similar a [0-9] |
| \\D | Coincide con cualquier carácter que no sea dígito |
| \\G | El inicio de la búsqueda actual |
| \\n | Salto de línea |
| \\b | Normalmente es el límite de una palabra, pero si se usa dentro de una clase de caracteres representa retroceso |
| \\B | Coincide con la posición que no es el inicio o final de una palabra |
| \\t | Tabulador |
| \\Q | Comillas de apertura:\Q(a+b)*3\EPuede coincidir con el texto "(a+b)*3". |
| \\E | Comillas de cierre:\Q(a+b)*3\EPuede coincidir con el texto "(a+b)*3". |
Ejemplos de expresiones regulares
| Ejemplo | Descripción |
|---|---|
| . | Coincide con cualquier carácter individual excepto "\r\n". |
| [Rr]uby | Coincide con "Ruby" o "ruby" |
| rub[ye] | Coincide con "ruby" o "rube" |
| [aeiou] | Coincide con las vocales minúsculas: aeiou |
| [0-9] | Coincide con cualquier dígito, similar a |
| [a-z] | Coincide con cualquier letra minúscula ASCII |
| [A-Z] | Coincide con cualquier letra mayúscula ASCII |
| [a-zA-Z0-9] | Coincide con dígitos y letras mayúsculas y minúsculas |
| [^aeiou] | Coincide con cualquier carácter excepto aeiou |
| [^0-9] | Coincide con cualquier carácter que no sea dígito |
| \\d | Coincide con dígitos, similar a: [0-9] |
| \\D | Coincide con no dígitos, similar a: [^0-9] |
| \\s | Coincide con espacios en blanco, similar a: [ \t\r\n\f] |
| \\S | Coincide con caracteres que no son espacios en blanco, similar a: [^ \t\r\n\f] |
| \\w | Coincide con letras, dígitos y guion bajo, similar a: [A-Za-z0-9_] |
| \\W | Coincide con caracteres que no son letras, dígitos ni guion bajo, similar a: [^A-Za-z0-9_] |
| ruby? | Coincide con "rub" o "ruby": la y es opcional |
| ruby* | Coincide con "rub" seguido de 0 o más y. |
| ruby+ | Coincide con "rub" seguido de 1 o más y. |
| \\d{3} | Coincide exactamente con 3 dígitos. |
| \\d{3,} | Coincide con 3 o más dígitos. |
| \\d{3,5} | Coincide con 3, 4 o 5 dígitos. |
| \\D\\d+ | Sin grupo: + repite \d |
| (\\D\\d)+/ | Con grupo: + repite el par \D\d |
| ([Rr]uby(, )?)+ | Coincide con "Ruby", "Ruby, ruby, ruby", etc. |
Ten en cuenta que cada carácter en la tabla anterior utiliza dos barras invertidas. Esto se debe a que en Java y Scala la barra invertida en las cadenas es un carácter de escape. Por lo tanto, si deseas generar\, debes escribirlo en la cadena como\\para obtener una barra invertida. Consulta el siguiente ejemplo:
Ejemplo
object Test {
def main(args: Array[String]) {
val pattern = new Regex("abl[ae]\\d+")
val str = "ablaw is able1 and cool"
println((pattern findAllIn str).mkString(","))
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test able1Otras extensiones