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 cadenas. En Kotlin, están implementadas basándose en las clases de Java Pattern y Matcher, pero el lenguaje añade sus propias extensiones convenientes y azúcar sintáctico. En este artículo, analizaremos cómo usar expresiones regulares en Kotlin con ejemplos reales: desde la búsqueda simple hasta el reemplazo y la división de cadenas.

Fundamentos de sintaxis: creación y compilación

En Kotlin, una expresión regular se puede crear de dos maneras: a través de la clase Regex o usando una cadena con un patrón. La primera forma es preferible, ya que proporciona más métodos.

// Forma 1: a través de la clase Regex\nval regex = Regex("\\\\d+") // uno o más dígitos\n\n// Forma 2: a través de una cadena (no recomendado para expresiones complejas)\nval pattern = "\\\\d+".toRegex()

Observa la doble barra invertida de escape: \\\\d — esto es un escape para Java/Kotlin, para obtener el carácter \\d en la cadena. Para simplificar, Kotlin admite cadenas raw (triples comillas """), donde no se requiere escape:

val regex = Regex("""\\d+""") // cadena raw — no es necesario duplicar las barras invertidas

También se pueden añadir banderas, por ejemplo, RegexOption.IGNORE_CASE:

val regex = Regex("kotlin", RegexOption.IGNORE_CASE)

Búsqueda y verificación de coincidencias

Las operaciones más comunes son verificar si una cadena contiene una subcadena según un patrón y encontrar todas las coincidencias.

Verificación de existencia de coincidencia: containsMatchIn

val text = "Mi número: 123-45-678"\nval digitRegex = Regex("""\\d+""")\n\nif (digitRegex.containsMatchIn(text)) {\n    println("¡El texto contiene dígitos!")\n}

Búsqueda de la primera coincidencia: find

val result = digitRegex.find(text)\nprintln(result?.value) // Imprime: 123

Búsqueda de todas las coincidencias: findAll

val allMatches = digitRegex.findAll(text)\nallMatches.forEach { match ->\n    println("Encontrado: ${match.value}") // 123, 45, 678\n}

El método findAll devuelve una secuencia de objetos MatchResult. Cada uno de estos objetos contiene no solo la coincidencia en sí (.value), sino también su posición en la cadena (.range).

Trabajo con grupos de captura

Los grupos de captura son partes del patrón encerradas entre paréntesis. Permiten extraer fragmentos de datos específicos. Por ejemplo, analicemos un email en nombre de usuario y dominio:

val email = "user@example.com"\nval emailRegex = Regex("""(.+)@(.+)""")\nval matchResult = emailRegex.find(email)\n\nif (matchResult != null) {\n    val (username, domain) = matchResult.destructured\n    println("Nombre de usuario: $username") // user\n    println("Dominio: $domain")             // example.com\n}

La construcción destructured descompone convenientemente los grupos en variables. Si hay más grupos, se puede acceder por índice:

val fullMatch = matchResult.value      // user@example.com\nval group1 = matchResult.groupValues[1] // user\nval group2 = matchResult.groupValues[2] // example.com

Grupos con nombre (Kotlin 1.7+)

A partir de Kotlin 1.7, se pueden usar grupos con nombre:

val namedRegex = Regex("""(?<name>\\w+)@(?<domain>\\w+\\.\\w+)""")\nval match = namedRegex.find("contact@kotlin.org")\nif (match != null) {\n    println(match.groups["name"]?.value)   // contact\n    println(match.groups["domain"]?.value) // kotlin.org\n}

Reemplazo de texto con replace

El método replace permite reemplazar todas las coincidencias con una nueva cadena. En el patrón de reemplazo, se puede hacer referencia a los grupos de captura con