¡Maestría en Procesamiento de Cadenas! Explorando las Expresiones Regulares en Ruby

🚀 Introducción a las Expresiones Regulares en Ruby

Las expresiones regulares, o Regexp como se les conoce en Ruby, son una herramienta increíblemente poderosa para la manipulación de cadenas de texto. Nos permiten buscar patrones complejos, extraer información específica, reemplazar partes de texto y validar formatos con una precisión asombrosa. Si trabajas con datos textuales, ya sean logs, entradas de usuario, archivos CSV o cualquier otra fuente, dominar las Regexp te abrirá un mundo de posibilidades.

Ruby integra las expresiones regulares de manera nativa y elegante, haciéndolas una parte fundamental del lenguaje. En este tutorial, exploraremos su sintaxis, sus operadores y cómo podemos aplicarlas en situaciones del mundo real para resolver problemas comunes de procesamiento de texto.

---

📚 Fundamentos de las Expresiones Regulares en Ruby

En Ruby, las expresiones regulares se crean usando literales /patron/ o instanciando la clase Regexp. Son objetos de primera clase, lo que significa que puedes almacenarlos en variables, pasarlos como argumentos y devolverlos desde métodos.

Creación de Expresiones Regulares

La forma más común y sencilla de crear una expresión regular es usando los delimitadores /.

# Usando literales Regexp
patron1 = /ruby/
patron2 = /\d{3}-\d{3}-\d{4}/ # Para un número de teléfono

# Usando la clase Regexp.new
patron3 = Regexp.new('ruby')
patron4 = Regexp.new('\d{3}-\d{3}-\d{4}') # Nota: las barras inversas deben escaparse en strings

puts patron1.class # => Regexp
puts patron3.class # => Regexp

Cuando creas una expresión regular a partir de una cadena con Regexp.new, debes tener cuidado con los caracteres de escape, ya que la cadena ya los interpreta. Por ejemplo, \d en una Regexp literal es \\d en una cadena.

Operadores Básicos de Coincidencia (Matching) con String#=~ y Regexp#match

Ruby ofrece varios métodos para probar si una cadena coincide con un patrón.

El operador =~ es el más directo. Devuelve el índice de inicio de la primera coincidencia si la encuentra, nil en caso contrario.

cadena = "Hola mundo, estamos aprendiendo Ruby."
patron = /Ruby/

if cadena =~ patron
  puts "'Ruby' encontrado en la posición #{cadena =~ patron}"
else
  puts "'Ruby' no encontrado"
end

cadena2 = "Python es genial."
if cadena2 =~ patron
  puts "'Ruby' encontrado"
else
  puts "'Ruby' no encontrado en '#{cadena2}'"
end
# Salida:
# 'Ruby' encontrado en la posición 30
# 'Ruby' no encontrado en 'Python es genial.'

El método Regexp#match (o String#match) devuelve un objeto MatchData si hay una coincidencia, y nil en caso contrario. El objeto MatchData es mucho más potente, ya que contiene información detallada sobre la coincidencia (capturas, posiciones, etc.).

cadena = "El año es 2023"
patron = /\d{4}/

match_data = patron.match(cadena)

if match_data
  puts "Coincidencia encontrada: #{match_data[0]}"
  puts "Posición de inicio: #{match_data.begin(0)}"
  puts "Posición de fin: #{match_data.end(0)}"
else
  puts "No se encontró coincidencia."
end
# Salida:
# Coincidencia encontrada: 2023
# Posición de inicio: 11
# Posición de fin: 15

También puedes usar String#match? para una verificación booleana rápida, que es más eficiente que match si solo necesitas saber si hay una coincidencia o no.

puts "El año es 2023".match?(/\d{4}/) # => true
puts "No hay números".match?(/\d{4}/)  # => false

---

🔍 Metacaracteres y Clases de Caracteres

Los metacaracteres son caracteres especiales que no coinciden literalmente con ellos mismos, sino que tienen un significado especial en una expresión regular.

Metacaracteres Comunes

Metacarácter	Descripción	Ejemplo	Coincide con
---	---	---	---
.	Cualquier carácter (excepto nueva línea por defecto)	/a.b/	acb, a!b, a3b
^	Inicio de la cadena/línea	/^Hola/	Hola mundo
---	---	---	---
$	Fin de la cadena/línea	/mundo$/	Hola mundo
*	Cero o más ocurrencias del elemento anterior	/a*b/	b, ab, aaab
---	---	---	---
+	Una o más ocurrencias del elemento anterior	/a+b/	ab, aaab (no b)
?	Cero o una ocurrencia del elemento anterior	/colou?r/	color, colour
---	---	---	---
`	`	OR lógico (alternancia)	`/perro
()	Grupo de captura y agrupación	/(ab)+/	ab, abab
---	---	---	---
[]	Conjunto de caracteres	/[aeiou]/	Cualquier vocal
[^]	Conjunto de caracteres negado	/[^0-9]/	Cualquier carácter no numérico
---	---	---	---
{n}	n ocurrencias exactas	/a{3}/	aaa
{n,}	n o más ocurrencias	/a{2,}/	aa, aaa, aaaa
---	---	---	---
{n,m}	Entre n y m ocurrencias	/a{2,4}/	aa, aaa, aaaa
\	Escape para caracteres especiales	/\./	El carácter literal .

Clases de Caracteres Predefinidas

Ruby, como otras implementaciones de Regexp, ofrece atajos para clases de caracteres comunes.

Clase	Descripción	Equivalente a
---	---	---
\d	Cualquier dígito	[0-9]
\D	Cualquier carácter que no sea un dígito	[^0-9]
---	---	---
\w	Cualquier carácter de palabra (alfanuméricos + guion bajo)	[a-zA-Z0-9_]
\W	Cualquier carácter que no sea de palabra	[^a-zA-Z0-9_]
---	---	---
\s	Cualquier carácter de espacio en blanco	[ \t\r\n\f\v]
\S	Cualquier carácter que no sea de espacio en blanco	[^ \t\r\n\f\v]
---	---	---
\b	Límite de palabra
\B	No es un límite de palabra

puts "El 2023 es un buen año".match?(/\d{4}/)  # Coincide con cuatro dígitos seguidos
puts "Mi email es test@example.com".match?(/\w+@\w+\.\w+/) # Email básico
puts "Espacio entre palabras".match?(/\s+/) # Uno o más espacios en blanco

¿Por qué `\` para escapar caracteres?

El uso de la barra invertida `\` para escapar metacaracteres permite distinguirlos de sus versiones literales. Por ejemplo, `.` significa "cualquier carácter", mientras que `\.` significa el carácter literal "punto". Esta convención es estándar en la mayoría de los motores de expresiones regulares.

---

🎯 Banderas (Flags) de Expresiones Regulares

Las banderas modifican el comportamiento de una expresión regular. Se añaden al final del literal o como segundo argumento de Regexp.new.

Bandera	Descripción
---	---
i	Ignorar mayúsculas/minúsculas (case-insensitive)
m	Modo multilinea: . coincide con nuevas líneas, ^ y $ coinciden con el inicio/fin de cada línea
---	---
x	Modo extendido: permite espacios en blanco y comentarios dentro de la Regexp (ignorados)
o	Interpola la expresión regular una sola vez (útil con variables)

# Bandera 'i' (ignore case)
puts "RUBY".match?(/ruby/i) # => true
puts "Ruby es genial".match?(/genial/i) # => true

# Bandera 'm' (multiline mode)
cadena = "Primera línea\nSegunda línea"
puts cadena.match?(/^Segunda/, 0)      # false (sin bandera 'm', ^ coincide con inicio de cadena)
puts cadena.match?(/^Segunda/m, 0)     # true (con bandera 'm', ^ coincide con inicio de línea)

# Bandera 'x' (extended mode) para mayor legibilidad
telefono_patron_x = / # Este es un comentario
  \A             # Inicio de la cadena
  (\d{3})        # Grupo de captura 1: tres dígitos
  [ -.]?        # Un espacio, guion o punto opcional
  (\d{3})        # Grupo de captura 2: tres dígitos
  [ -.]?        # Un espacio, guion o punto opcional
  (\d{4})        # Grupo de captura 3: cuatro dígitos
  \Z             # Fin de la cadena
/x

puts telefono_patron_x.match?("123-456-7890") # => true
puts telefono_patron_x.match?("123 456 7890") # => true
puts telefono_patron_x.match?("123.456.7890") # => true

---

🔗 Grupos de Captura y Referencias Hacia Atrás

Los paréntesis () no solo agrupan partes de una expresión regular, sino que también capturan el texto que coincide con esa parte. Puedes acceder a estas capturas después de una coincidencia.

Accediendo a las Capturas

Cuando usas match o =~, Ruby establece variables globales especiales para las capturas:

• $1, $2, $3, etc., para cada grupo de captura.
• $& para toda la coincidencia.
• $ (o $~) para el último objeto MatchData.

texto = "Nombre: Juan, Edad: 30, Ciudad: Madrid"
patron = /Nombre: (\w+), Edad: (\d+), Ciudad: (\w+)/

if texto =~ patron
  puts "Coincidencia completa: #{$&}"
  puts "Nombre: #{$1}"
  puts "Edad: #{$2}"
  puts "Ciudad: #{$3}"

  # También puedes usar el objeto MatchData directamente
  match_data = $~
  puts "Nombre (desde MatchData): #{match_data[1]}"
end
# Salida:
# Coincidencia completa: Nombre: Juan, Edad: 30, Ciudad: Madrid
# Nombre: Juan
# Edad: 30
# Ciudad: Madrid
# Nombre (desde MatchData): Juan

Grupos de No Captura

Si quieres agrupar partes de una expresión regular sin que se capturen, usa (?:...).

texto = "manzana verde"
patron = /(?:manzana|pera) (verde|roja)/

match_data = patron.match(texto)
if match_data
  puts "Fruta y color: #{match_data[0]}"
  puts "Color capturado: #{match_data[1]}"
  # puts match_data[2] # Esto daría error, porque (?:manzana|pera) no es un grupo de captura
end
# Salida:
# Fruta y color: manzana verde
# Color capturado: verde

Referencias Hacia Atrás (Backreferences)

Puedes referenciar un grupo de captura anterior dentro de la misma expresión regular usando \1, \2, etc.

# Buscar palabras duplicadas consecutivas
patron = /(\w+)\s+\1/

puts "Ella ella fue".match?(patron) # => true (ella y ella)
puts "El coche coche es rojo".match?(patron) # => true (coche y coche)
puts "Ruby es es genial".match?(patron) # => true (es y es)
puts "Hola mundo".match?(patron)      # => false

---

🔄 Reemplazo de Cadenas con Expresiones Regulares

Ruby proporciona métodos muy útiles para reemplazar partes de cadenas que coinciden con una expresión regular.

String#sub y String#gsub

• sub: Reemplaza la primera ocurrencia que coincide con el patrón.
• gsub: Reemplaza todas las ocurrencias que coinciden con el patrón.

Ambos métodos no modifican la cadena original; devuelven una nueva cadena con los reemplazos. Las versiones con ! (ej. sub!, gsub!) modifican la cadena in-place.

cadena = "Mi número es 123-456-7890 y el otro es 987-654-3210."

# Reemplazar solo el primer número
puts cadena.sub(/\d{3}-\d{3}-\d{4}/, '[NÚMERO_OCULTO]')
# => "Mi número es [NÚMERO_OCULTO] y el otro es 987-654-3210."

# Reemplazar todos los números
puts cadena.gsub(/\d{3}-\d{3}-\d{4}/, '[NÚMERO_OCULTO]')
# => "Mi número es [NÚMERO_OCULTO] y el otro es [NÚMERO_OCULTO]."

# Usando bloques para el reemplazo (gsub es muy flexible)
email_lista = "john@example.com, jane@domain.org, bob@test.net"
puts email_lista.gsub(/(\w+)@(\w+\.\w+)/) { |match| "Email: #{$1} (Dominio: #{$2})" }
# => "Email: john (Dominio: example.com), Email: jane (Dominio: domain.org), Email: bob (Dominio: test.net)"

# También puedes usar referencias hacia atrás en la cadena de reemplazo
fecha = "2023-10-26"
puts fecha.sub(/(\d{4})-(\d{2})-(\d{2})/, '\3/\2/\1') # Formato DD/MM/AAAA
# => "26/10/2023"

---

🔪 División de Cadenas con Expresiones Regulares: String#split

El método String#split te permite dividir una cadena en un array de subcadenas, utilizando un patrón de expresión regular como delimitador.

cadena_datos = "id:101;nombre:Alice;edad:30;ciudad:NY"

# Dividir por ';' o ':'
partes = cadena_datos.split(/[:;]/)
puts partes.inspect # => ["id", "101", "nombre", "Alice", "edad", "30", "ciudad", "NY"]

# Dividir por cualquier espacio en blanco
frase = "Hola   mundo,   que tal."
palabras = frase.split(/\s+/)
puts palabras.inspect # => ["Hola", "mundo,", "que", "tal."]

# Dividir por comas, opcionalmente seguidas de espacio
csv_data = "manzana,pera, kiwi, platano"
items = csv_data.split(/,\s*/)
puts items.inspect # => ["manzana", "pera", "kiwi", "platano"]

Límite de División

split también acepta un argumento limit para controlar cuántas divisiones se realizan.

path = "/usr/local/bin/ruby"

# Dividir en 3 partes como máximo
partes = path.split('/', 3)
puts partes.inspect # => ["", "usr", "local/bin/ruby"]

---

✨ Ejemplos Avanzados y Casos de Uso Comunes

Las expresiones regulares brillan en tareas complejas de procesamiento de texto. Veamos algunos ejemplos prácticos.

📧 Validación de Email (Básica)

La validación de email es un clásico. Aunque una Regexp perfecta es extremadamente compleja, una básica es suficiente para muchos casos.

def es_email_valido?(email)
  email_patron = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
  email.match?(email_patron)
end

puts "test@example.com: #{es_email_valido?('test@example.com')}" # => true
puts "invalid-email: #{es_email_valido?('invalid-email')}"       # => false
puts "user@sub.domain.co.uk: #{es_email_valido?('user@sub.domain.co.uk')}" # => true

📞 Extracción de Números de Teléfono

Extraer información estructurada de texto no estructurado es una fortaleza de las Regexp.

def extraer_telefonos(texto)
  telefono_patron = /\b\d{3}[-. ]?\d{3}[-. ]?\d{4}\b/
  texto.scan(telefono_patron) # String#scan devuelve un array con todas las coincidencias
end

texto = "Llama al 123-456-7890 o al 555 123 4567. Mi oficina es 999.888.7777."
telefonos = extraer_telefonos(texto)
puts "Teléfonos encontrados: #{telefonos.inspect}"
# Salida:
# Teléfonos encontrados: ["123-456-7890", "555 123 4567", "999.888.7777"]

📅 Reemplazo de Formato de Fecha

Transformar formatos es sencillo con grupos de captura y reemplazo.

def reformatear_fecha(fecha_str)
  fecha_str.sub(/(\d{4})-(\d{2})-(\d{2})/, '\3/\2/\1')
end

puts "Fecha original: 2024-01-15 -> Formateada: #{reformatear_fecha('2024-01-15')}"
# Salida:
# Fecha original: 2024-01-15 -> Formateada: 15/01/2024

🗑️ Eliminar Etiquetas HTML (Básica)

Con un patrón más robusto, puedes limpiar etiquetas HTML. ¡Pero ten cuidado, las Regexp no son un parser de HTML completo!

def limpiar_html_tags(html_content)
  html_content.gsub(/<[^>]+>/, '')
end

html_ejemplo = "<p>Hola <strong>mundo</strong>!</p> <a href='#'>Link</a>"
puts "HTML original: #{html_ejemplo}"
puts "HTML limpio: #{limpiar_html_tags(html_ejemplo)}"
# Salida:
# HTML original: <p>Hola <strong>mundo</strong>!</p> <a href='#'>Link</a>
# HTML limpio: Hola mundo! Link

---

📈 Optimizando el Rendimiento de Regexp

Las expresiones regulares son potentes, pero un patrón mal escrito puede ser muy ineficiente (problemas como el catastrophic backtracking). Aquí algunos consejos:

• Sé específico: Usa clases de caracteres específicas (ej. \d) en lugar de . cuando sea posible.
• Evita el backtracking excesivo: Los cuantificadores greedy (por defecto) combinados con patrones complejos pueden llevar a un rendimiento pobre. Considera los cuantificadores lazy (*?, +?, ??) que coinciden con la menor cantidad de texto posible.
• Anclas (^, $, \A, \Z): Usarlas para fijar el inicio o fin de la coincidencia puede reducir enormemente el trabajo del motor de Regexp.
• Grupos de no captura (?:...): Si no necesitas capturar el contenido de un grupo, usa (?:...) en lugar de (...) para una ligera mejora de rendimiento.
• Precompila patrones: Si usas la misma Regexp muchas veces, Ruby la precompila automáticamente. Sin embargo, si la creas dinámicamente con Regexp.new dentro de un bucle, asegúrate de que el patrón no cambie o precompílalo fuera del bucle.

require 'benchmark'

long_string = "a" * 100_000 + "b"

Benchmark.bm do |x|
  x.report("Greedy:") { 100.times { long_string.match(/a*a*b/) } }
  x.report("Lazy:")   { 100.times { long_string.match(/a*?a*?b/) } }
  x.report("Specific:") { 100.times { long_string.match(/a+b/) } }
end
# Salida (valores aproximados, varían según máquina):
#          user     system      total        real
# Greedy:  0.030000   0.000000   0.030000 (  0.030438)
# Lazy:    0.020000   0.000000   0.020000 (  0.020076)
# Specific:  0.000000   0.000000   0.000000 (  0.000003)

En este ejemplo, el patrón a+b es el más eficiente porque es el más específico. Los patrones con * pueden ser más lentos si hay muchas a seguidas de b.

---

🌐 Recursos Adicionales

Para profundizar en las expresiones regulares y Ruby:

• Documentación oficial de Regexp en Ruby
• Regexp Tutorial
• Rubular (Online Regexp editor)
• RegExr (Online Regexp editor)

---

🏁 Conclusión

Las expresiones regulares son una herramienta indispensable en el arsenal de cualquier desarrollador Ruby. Aunque pueden parecer intimidantes al principio, con práctica y un entendimiento claro de sus fundamentos, podrás manipular y procesar texto de maneras que antes parecían imposibles.

Hemos cubierto desde la sintaxis básica y los metacaracteres, hasta grupos de captura, reemplazos y algunos ejemplos avanzados. Recuerda que la clave para dominar las Regexp es la práctica constante y la experimentación. ¡Ahora estás listo para aplicar esta maestría en tus proyectos Ruby!