Expresión regular de Kotlin

Las expresiones regulares son una parte fundamental de casi todos los lenguajes de programación y Kotlin no es una excepción. En Kotlin, el soporte para expresiones regulares se proporciona a través de la clase Regex . Un objeto de esta clase representa una expresión regular, que se puede utilizar con fines de coincidencia de strings.  

class Regex

Podemos encontrar fácilmente el uso de expresiones regulares en diferentes tipos de software, desde las aplicaciones más simples hasta las increíblemente complejas. 
Antes de leer este artículo, eche un vistazo a Expresiones regulares en Java
 

constructores –

1. <init>(patrón: String) : Este constructor crea una expresión regular basada en la string del patrón. 
    
2. <init>(patrón: String, opción: RegexOption) : este constructor crea una expresión regular basada en el patrón especificado y la opción. La opción es una constante de la clase de enumeración RegexOption. 
    
3. <init>(pattern: String, options: Set<RegexOption>) : este constructor crea una expresión regular sobre la base del patrón de string especificado y el conjunto de opciones especificado en el conjunto. 
    

Propiedades –

1. val options: Set<RegexOption> : contiene el conjunto de opciones que se utilizarán en el momento de la creación de expresiones regulares. 
    
2. val pattern: String : Contiene la string que describe el patrón. 
    

Funciones Regex –

containsMatchIn(): esta función devuelve un booleano que indica si existe alguna coincidencia de nuestro patrón en la entrada. 

fun containsMatchIn(input: CharSequence): Boolean

Ejemplo para demostrar la función containsMatchIn() en Kotlin 

fun main()
{
    // Regex to match any string starting with 'a'
    val pattern = Regex("^a")
    println(pattern.containsMatchIn("abc"))
    println(pattern.containsMatchIn("bac"))
}

Producción: 

true
false

find(): esta función devuelve la primera substring coincidente perteneciente a nuestro patrón en la entrada, desde el 
índice de inicio especificado. 

fun find(input: CharSequence, startIndex: Int): MatchResult?

Ejemplo para demostrar la función find() en Kotlin 

fun main()
{
    // Regex to match "ll" in a string
    val pattern1 = Regex("ll")
    val ans : MatchResult? = pattern1.find("HelloHello", 5)
    println(ans ?.value)
}

Producción: 

ll

findAll(): esta función devuelve todas las coincidencias del patrón especificado en la entrada, buscando desde el índice de inicio dado. 

fun findAll(
    input: CharSequence, 
    startIndex: Int
): Sequence

Ejemplo para demostrar la función findAll en Kotlin 

fun main()
{
    // Regex to match a 3 letter pattern beginning with ab
    val pattern2 = Regex("ab.")
    val ans1 : Sequence<MatchResult> = pattern2.findAll("abcfffgdbabs", 0)
    // forEach loop used to display all the matches
    ans1.forEach()
    {
            matchResult -> println(matchResult.value)
    }
    println()
}

Producción: 

abc
abs

matches(): esta función devuelve un valor booleano que indica si la string de entrada coincide completamente con el patrón o no. 
 

infix fun matches(input: CharSequence): Boolean

Ejemplo para demostrar la función de coincidencias() en Kotlin 

fun main()
{
    // Tests demonstrating entire string match
    val pattern = Regex("g([ee]+)ks?")
    println(pattern.matches("geeks"))
    println(pattern.matches("geeeeeeeeeeks"))
    println(pattern.matches("geeksforgeeks"))
}

Producción:  

true
true
false

matchEntire(): esta función intenta hacer coincidir toda la entrada con la string de patrón especificada y devuelve la string si coincide. Si no coincide con la string, devuelve nulo .  

fun matchEntire(input: CharSequence): MatchResult?

Ejemplo para demostrar la función matchEntire() en Kotlin 

fun main()
{
    // Tests demonstrating entire string match
    var pattern = Regex("geeks?")
    println(pattern.matchEntire("geeks")?.value)
    println(pattern.matchEntire("geeeeeeeks")?.value)
    pattern = Regex("""\D+""")
    println(pattern.matchEntire("geeks")?.value)
    println(pattern.matchEntire("geeks12345")?.value)
}

Producción: 

geeks
null
geeks
null

replace(): esta función reemplaza todas las ocurrencias del patrón en la string de entrada con la string de reemplazo especificada.  

fun replace(input: CharSequence, replacement: String): String

replaceFirst(): esta función reemplaza la primera coincidencia de la expresión regular en la entrada con la string de reemplazo.  

fun replaceFirst(
    input: CharSequence, 
    replacement: String
): String

Ejemplo para demostrar las funciones replace() y replaceFirst() en Kotlin 

fun main()
{
    // Tests demonstrating replacement functions
    val pattern4 = Regex("xyz")
    // replace all xyz with abc in the string
    println(pattern4.replace("xyzxyzzzzzzzzz", "abc"))
    // replace only first xyz with abc not all
    println(pattern4.replaceFirst("xyzddddddxyz", "abc"))
    println()
}

Producción:  

abcabczzzzzzzz    // replace all
abcddddddxyz      // replace first matching only

split(): esta función divide la string de entrada en tokens de acuerdo con el parámetro especificado.  

fun split(input: CharSequence, limit: Int): List

Ejemplo para demostrar la función split() en Kotlin 

fun main()
{
    // Tests demonstrating split function
    val pattern = Regex("\\s+")  // separate for white-spaces
    val ans : List<String> = pattern.split("This is a sentence")
    ans.forEach { word -> println(word) }
}

Producción: 

This
is
a
sentence