Expresiones regulares en Kotlin con ejemplos: en la práctica

Expresiones regulares en Kotlin con ejemplos: en la práctica

Las expresiones regulares (regex) son una herramienta poderosa para trabajar con texto, que permite realizar búsqueda, reemplazo y validación de cadenas según un patrón. En Kotlin, el trabajo con expresiones regulares se implementa a través de la clase Regex y un conjunto de funciones de extensión convenientes. En este artículo, analizaremos la sintaxis, los métodos principales y veremos ejemplos prácticos que te ayudarán a dominar rápidamente regex en Kotlin.

1. Fundamentos del trabajo con la clase Regex

En Kotlin, una expresión regular se crea con la clase Regex. El patrón se puede definir con una cadena normal o con una raw-string (triples comillas """), lo cual es especialmente útil para no tener que escapar las barras invertidas.

// Cadena normalval pattern1 = Regex("\\\\d+")  // uno o más dígitos

// Raw-string (recomendado)val pattern2 = Regex("""\\d+""") // lo mismo, pero sin escapado

La clase Regex también acepta banderas opcionales, por ejemplo, RegexOption.IGNORE_CASE para búsqueda sin distinción de mayúsculas y minúsculas.

val caseInsensitive = Regex("""hello""", RegexOption.IGNORE_CASE)

2. Métodos principales: match, find, replace

Kotlin proporciona varios métodos clave para trabajar con expresiones regulares. Veamos los más populares.

2.1. Método matchEntire (coincidencia completa)

Verifica si toda la cadena coincide con el patrón. Devuelve MatchResult? o null.

val regex = Regex("""\\d{3}-\\d{2}-\\d{4}""")val text = "123-45-6789"val matchResult = regex.matchEntire(text)println(matchResult?.value) // Salida: 123-45-6789

// Si la cadena no coincide con el patrónval badText = "123-45-678"println(regex.matchEntire(badText)) // Salida: null

2.2. Método find (primera coincidencia)

Busca la primera aparición del patrón en la cadena. Devuelve MatchResult?.

val regex = Regex("""\\d+""")val text = "Precio: 150 rublos, descuento: 30%"val firstMatch = regex.find(text)println(firstMatch?.value) // Salida: 150

2.3. Método findAll (todas las coincidencias)

Encuentra todas las apariciones no superpuestas del patrón. Devuelve una secuencia de MatchResult.

val regex = Regex("""\\d+""")val text = "Precio: 150 rublos, descuento: 30%"val allMatches = regex.findAll(text)allMatches.forEach { println(it.value) }// Salida:// 150// 30

2.4. Método replace (reemplazo)

Reemplaza todas las apariciones del patrón con la cadena especificada o el resultado de una lambda.

val regex = Regex("""\\d+""")val text = "ID: 12345, código: 67890"val result = regex.replace(text, "***")println(result) // Salida: ID: ***, código: ***

// Reemplazo usando lambda (reemplazo dinámico)val dynamicResult = regex.replace(text) { matchResult ->    "[" + matchResult.value.toInt().toString() + "]"}println(dynamicResult) // Salida: ID: [12345], código: [67890]

3. Grupos de captura (capturing groups)

Los grupos de captura permiten extraer partes de una coincidencia. En Kotlin, se puede acceder a los grupos por índice o por nombre (si se define).

3.1. Acceso por índice

val regex = Regex("""(\\d{2})\\.(\\d{2})\\.(\\d{4})""") // fecha en formato DD.MM.AAAAval text = "Hoy: 15.03.2024"val match = regex.find(text)if (match != null) {    val (day, month, year) = match.destructured    println("Día: $day, Mes: $month, Año: $year")    // Salida: Día: 15, Mes: 03, Año: 2024}

3.2. Grupos con nombre

En Kotlin se pueden usar grupos con nombre (sintaxis (?<name>...)).

val regex = Regex("""(?<username>\\w+)@(?<domain>\\w+\\.\\w+)""")val text = "email: user@example.com"val match = regex.find(text)if (match != null) {    val username = match.groups["u