Expresiones regulares en Kotlin: guía completa con ejemplos

Expresiones Regulares en Kotlin: De Principiantes a Técnicas Avanzadas

Las expresiones regulares (regex) son una herramienta poderosa para buscar, extraer y reemplazar texto basado en un patrón. En Kotlin, trabajar con expresiones regulares se implementa a través de la clase Regex, que proporciona una API rica para todas las operaciones estándar. En este artículo, cubriremos la sintaxis, las funciones principales y ejemplos prácticos del uso de expresiones regulares en Kotlin.

1. Creación y Sintaxis Básica de Regex en Kotlin

En Kotlin, una expresión regular se crea usando la clase Regex o mediante la extensión .toRegex() para cadenas. Se admiten todos los metacaracteres y cuantificadores estándar.

Formas de crear un Regex:

// Método 1: mediante constructorval regex = Regex("\\\\d{3}-\\\\d{2}-\\\\d{4}")

// Método 2: mediante toRegex()val pattern = "[a-z]+@[a-z]+\\\\.[a-z]+".toRegex()

// Método 3: con opciones (sin distinción de mayúsculas/minúsculas)val caseInsensitive = Regex("kotlin", RegexOption.IGNORE_CASE)

Metacaracteres y cuantificadores básicos:

• . — cualquier carácter (excepto nueva línea)
• \\d — dígito (0-9)
• \\w — letra, dígito o guión bajo
• \\s — carácter de espacio en blanco
• ^ — inicio de cadena
• $ — fin de cadena
• * — 0 o más repeticiones
• + — 1 o más repeticiones
• ? — 0 o 1 repetición
• {n,m} — de n a m repeticiones

2. Operaciones Básicas: Búsqueda, Verificación y Extracción

La clase Regex proporciona varios métodos para trabajar con texto. Veamos los más importantes.

Verificación de coincidencia (matches)

El método matches() verifica si toda la cadena coincide completamente con el patrón:

val phonePattern = Regex("\\\\+7\\\\d{10}")println(phonePattern.matches("+79261234567")) // trueprintln(phonePattern.matches("+7926123456")) // false (9 dígitos en lugar de 10)

Encontrar la primera coincidencia (find)

El método find() devuelve la primera coincidencia como un objeto MatchResult?:

val text = "Contactos: email@test.com y support@domain.org"val emailRegex = "[\\\\w.]+@[\\\\w.]+\\\\.[a-z]+".toRegex()val match = emailRegex.find(text)println(match?.value) // email@test.comprintln(match?.range) // 10..23 (índices de inicio y fin)

Encontrar todas las coincidencias (findAll)

Para obtener todas las coincidencias, use findAll(), que devuelve un Sequence<MatchResult>:

val allMatches = emailRegex.findAll(text)allMatches.forEach { match ->    println("Encontrado: ${match.value} en posición ${match.range.first}")}// Salida:// Encontrado: email@test.com en posición 10// Encontrado: support@domain.org en posición 28

Verificación de existencia (containsMatchIn)

El método containsMatchIn() devuelve un Boolean — si hay al menos una coincidencia:

val hasEmail = emailRegex.containsMatchIn(text)println(hasEmail) // true

3. Reemplazo y división usando Regex

Las expresiones regulares son excelentes para reemplazar partes de una cadena y dividir texto.

Reemplazar la primera coincidencia (replaceFirst)

val original = "ID: 12345, código: 67890"val digitRegex = "\\\\d+".toRegex()val masked = digitRegex.replaceFirst(original, "***")println(masked) // ID: ***, código: 67890

Reemplazar todas las coincidencias (replace)

val censored = digitRegex.replace(original, "***")println(censored) // ID: ***, código: ***

Reemplazo usando una lambda

Puede pasar una lambda que se llamará para cada coincidencia