Expresiones regulares en Ruby: =~, match, scan y gsub
Una expresión regular (en inglés, regular expression o regex) es una manera de describir un patrón de caracteres para buscarlo dentro de una cadena de texto.
Es como describir a alguien para encontrarlo entre la multitud: no dices su nombre, dices «busco a alguien con gafas, pelo corto y camiseta roja». Cualquiera que cumpla la descripción coincide. Una regex hace lo mismo con el texto: «dos dígitos, dos puntos, dos dígitos» encuentra cualquier hora, sea la que sea.
En Ruby, como es Ruby, las expresiones regulares son objetos (de la clase Regexp) y se pueden manipular como tales: guardarlas en variables, pasarlas a métodos o combinarlas.
Todos los ejemplos están ejecutados en Ruby 4.0.9 y la salida que ves es la real.
Chuleta de metacaracteres
Los metacaracteres son los símbolos que tienen un significado especial dentro del patrón.
| Símbolo | Significa | Ejemplo | Coincide con |
|---|---|---|---|
. |
Cualquier carácter salvo el salto de línea | /a.b/ |
"acb", "a-b" |
\d / \D |
Un dígito / cualquier cosa que no sea un dígito | /\d\d/ |
"42" |
\w / \W |
Letra ASCII, dígito o _ / lo contrario |
/\w+/ |
"hola_1" (pero no la ñ ni las tildes) |
\s / \S |
Espacio, tabulador, salto de línea… / lo contrario | /a\sb/ |
"a b" |
[abc] |
Uno de esos caracteres | /[aeiou]/ |
"a", "e" |
[a-z] |
Un carácter del rango | /[0-9]/ |
"7" |
[^abc] |
Cualquiera menos esos | /[^a-z]+/ |
"123" en "abc123" |
| |
Una cosa o la otra | /Java|Ruby/ |
"Java", "Ruby" |
( ) |
Agrupa y captura | /J(ava|ruby)/ |
"Java", "Jruby" |
(?: ) |
Agrupa sin capturar | /Java(?:script)?/ |
"Java", "Javascript" |
* |
Cero o más veces | /Java *Ruby/ |
"JavaRuby", "Java Ruby" |
+ |
Una o más veces | /\d+/ |
"7", "2026" |
? |
Cero o una vez (opcional) | /colou?r/ |
"color", "colour" |
{n} / {n,m} |
Exactamente n / entre n y m veces | /\d{2}/ |
"12" |
*?, +? |
Lo mismo, pero lo más corto posible | /<.+?>/ |
"<b>" en "<b>x</b>" |
^ / $ |
Principio / final de línea | /^Hola/ |
"Hola" al empezar cualquier línea |
\A / \z |
Principio / final de todo el texto | /\A\d+\z/ |
"2026", pero no "2026\nhola" |
\b |
Límite de palabra | /\bmundo\b/ |
"mundo" en "hola mundo" |
[[:alpha:]], \p{L} |
Cualquier letra, también ñ y con tilde |
/[[:alpha:]]+/ |
"Ñandú" |
Si quieres buscar un metacarácter tal cual (un punto, un +…), escápalo con \: /1\+1/. O deja que Ruby lo haga por ti con Regexp.escape("1+1=2?"), que devuelve "1\\+1=2\\?".
Primeros patrones
El ejemplo clásico: un patrón que coincida con un texto que contiene Java o Javascript.
p "Aprendo Javascript"[/Java|Javascript/] # => "Java"
p "Aprendo Javascript"[/Java(?:script)?/] # => "Javascript"
Las barras / / delimitan el patrón y | significa «o lo de la izquierda o lo de la derecha». Pero fíjate en la primera línea: Ruby prueba las alternativas por orden y se queda con la primera que encaja. Como Java ya coincide, nunca llega a probar Javascript. Para que funcione como esperas, pon primero la alternativa larga (/Javascript|Java/) o, mejor, di que script es opcional: /Java(?:script)?/.
texto[/patrón/] es la forma más corta de sacar lo que ha coincidido: devuelve el texto encontrado o nil.
Otros patrones habituales (todos devuelven true):
"Son las 12:34:56".match?(/\d\d:\d\d:\d\d/) # tipo reloj: 12:34:56
"Java y Javascript".match?(/Java.*Javascript/) # Java, cero o más caracteres cualesquiera y Javascript
"Java Javascript".match?(/Java Javascript/) # Java, un espacio y Javascript
"JavaJavascript".match?(/Java *Javascript/) # Java, cero o más espacios y Javascript
"Java Javascript".match?(/Java +Javascript/) # Java, uno o más espacios y Javascript
"Java\tJavascript".match?(/Java\s+Javascript/) # Java, uno o más espacios en blanco (o tabuladores) y Javascript
"Aprendiendo Java".match?(/Aprendiendo (Java|Javascript)/) # Aprendiendo, un espacio y Java o Javascript
El patrón de la hora también se puede escribir más corto con {2}: /\d{2}:\d{2}:\d{2}/.
Formas de crear expresiones regulares
a = Regexp.new('^\s*[a-z]') # => /^\s*[a-z]/
b = /^\s*[a-z]/ # => /^\s*[a-z]/
c = %r{^\s*[a-z]} # => /^\s*[a-z]/
Las tres crean el mismo objeto. Lo normal es usar las barras. %r{} es útil cuando el patrón lleva barras, como una ruta: %r{/usr/local/bin} se lee mejor que /\/usr\/local\/bin/.
Regexp.new tiene sentido cuando construyes el patrón a partir de datos. También puedes meter una variable en un literal con #{}:
lenguaje = "Ruby"
p "Aprendo Ruby".match?(/#{lenguaje}/) # => true
Si la variable viene del usuario, escápala con Regexp.escape para que un + o un . no cambien el significado del patrón.
Buscar: =~, match? y match
Ruby tiene tres formas de comprobar si un patrón aparece en un texto. Cada una devuelve algo distinto:
| Método | Devuelve | Úsalo para |
|---|---|---|
texto.match?(/re/) |
true o false |
Preguntar «¿está?». Es la más rápida porque no guarda nada. |
texto =~ /re/ |
La posición donde empieza la coincidencia, o nil |
Saber dónde empieza |
texto.match(/re/) |
Un objeto MatchData, o nil |
Trabajar con lo que ha coincidido y sus grupos |
frase = "0123456789Java"
p frase =~ /Java|Javascript/ # => 10 (empieza en la posición 10)
p "Ruby" =~ /Java/ # => nil
p frase.match?(/Java/) # => true
Como nil cuenta como falso en Ruby, puedes usar =~ directamente en un if. Pero si luego vas a usar lo que ha coincidido, no repitas la búsqueda: guarda el MatchData una vez y pregúntale todo a él.
frase = "0123456789Java"
if (m = frase.match(/Java|Javascript/))
puts "Encontré '#{m[0]}' en la posición #{m.begin(0)}"
end
Encontré 'Java' en la posición 10
m[0] es el texto completo que ha coincidido y m.begin(0), la posición donde empieza.
Grupos y capturas con nombre
Los paréntesis capturan partes de la coincidencia. Puedes recuperarlas por número, pero es más legible darles nombre con (?<nombre>…):
m = "2026-11-07".match(/(?<anio>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})/)
p m # => #<MatchData "2026-11-07" anio:"2026" mes:"11" dia:"07">
p m[:mes] # => "11"
p m["dia"] # => "07"
p m.captures # => ["2026", "11", "07"]
p m.named_captures # => {"anio" => "2026", "mes" => "11", "dia" => "07"}
Hay un atajo: si la regex escrita con barras va a la izquierda de =~, Ruby crea variables locales con el nombre de cada grupo.
if /(?<anio>\d{4})-(?<mes>\d{2})/ =~ "Fecha: 2026-11"
p anio # => "2026"
p mes # => "11"
end
Si pones el texto a la izquierda ("Fecha: 2026-11" =~ /…/), las variables no se crean. Es fácil olvidarlo, así que muchas veces compensa usar match y leer m[:anio].
También puedes sacar un solo grupo sin MatchData: "2026-11-07"[/(\d+)-(\d+)/, 2] devuelve "11".
Todas las coincidencias: scan
match se queda con la primera coincidencia. scan las devuelve todas en un array:
p "Llamé al 600 123 456 y al 922 000 111".scan(/\d{3} \d{3} \d{3}/)
# => ["600 123 456", "922 000 111"]
p "a=1, b=2".scan(/(\w)=(\d)/)
# => [["a", "1"], ["b", "2"]]
Si el patrón tiene grupos, cada resultado es un array con lo que capturó cada grupo.
Sustituir: sub y gsub
sub cambia la primera aparición y gsub (de global) cambia todas:
frase = "Java0123456789Java"
p frase.sub(/Java/, "Ruby") # => "Ruby0123456789Java"
p frase.gsub(/Java/, "Ruby") # => "Ruby0123456789Ruby"
p frase # => "Java0123456789Java" (no se modifica)
No hace falta comprobar antes con =~ si hay coincidencia: si no la hay, sub y gsub devuelven el texto sin cambios. Las versiones con exclamación (sub!, gsub!) modifican el propio texto y devuelven nil si no han cambiado nada, así que no las encadenes.
En el reemplazo puedes usar los grupos capturados, con su número o su nombre. Ponlo entre comillas simples para que Ruby no interprete las barras:
p "2026-11-07".sub(/(\d+)-(\d+)-(\d+)/, '\3/\2/\1')
# => "07/11/2026"
p "2026-11-07".sub(/(?<anio>\d+)-(?<mes>\d+)-(?<dia>\d+)/, '\k<dia>/\k<mes>/\k<anio>')
# => "07/11/2026"
Y si el reemplazo depende de lo encontrado, pasa un bloque o un hash:
p "precio: 10 y 20".gsub(/\d+/) { |n| (n.to_i * 2).to_s }
# => "precio: 20 y 40"
p "Java y Javascript".gsub(/Java(script)?/, "Java" => "Ruby", "Javascript" => "TypeScript")
# => "Ruby y TypeScript"
Antes, durante y después de la coincidencia
Tras una búsqueda con =~ o match, Ruby guarda el resultado en unas variables especiales heredadas de Perl. $~ es el último MatchData, y $&, $` y $' son lo que coincidió, lo de antes y lo de después:
texto = "Hola, ¿qué pasó?"
texto =~ /a/
p $` # => "Hol"
p $& # => "a"
p $' # => ", ¿qué pasó?"
Funcionan, pero cuesta leerlas y cualquier búsqueda posterior las sobrescribe. El mismo resultado, con nombres que se entienden:
Variables globales
texto =~ /a/$`→"Hol"$&→"a"$'→", ¿qué pasó?"
MatchData
m = texto.match(/a/)m.pre_match→"Hol"m[0]→"a"m.post_match→", ¿qué pasó?"
Un detalle que despista: match? no toca $~. Si haces "abc".match?(/b/) después de otra búsqueda, $~ sigue teniendo el resultado de la anterior.
Guarda el MatchData y pregúntale a él.
Modificadores: i, m y x
Van detrás de la barra de cierre y cambian cómo se aplica el patrón:
p "RUBY".match?(/ruby/i) # => true (i: no distingue mayúsculas)
p "a\nb".match?(/a.b/) # => false (el punto no acepta saltos de línea…)
p "a\nb".match?(/a.b/m) # => true (…salvo con m)
hora = /
(?<hora>\d{2}) : # horas
(?<min>\d{2}) # minutos
/x # x: ignora espacios y permite comentarios
p "Son las 12:34".match(hora)[:hora] # => "12"
Ojo si vienes de otro lenguaje: en Ruby, /m hace que el punto acepte saltos de línea. Lo que en JavaScript o Python hace la m (que ^ y $ funcionen por línea) en Ruby ya pasa siempre.
Validar un texto entero: \A y \z
Precisamente porque ^ y $ marcan el principio y el final de cada línea, no sirven para validar:
p "hola\nadmin" =~ /^admin$/ # => 5 (¡coincide en la segunda línea!)
p "hola\nadmin".match?(/\Aadmin\z/) # => false
Si compruebas que un campo es solo un número o solo un nombre de usuario, usa \A (principio del texto) y \z (final del texto). \Z, con mayúscula, admite además un salto de línea al final: "admin\n".match?(/\Aadmin\Z/) devuelve true.
Regex en case/when
Un case acepta expresiones regulares en cada when, lo que viene bien para clasificar textos (cómo funciona case, el switch de Ruby, está en condicionales en Ruby):
def tipo(texto)
case texto
when /\A\d+\z/ then "número"
when /\A[[:alpha:]]+\z/ then "palabra"
else "otra cosa"
end
end
p tipo("42") # => "número"
p tipo("hola") # => "palabra"
p tipo("4x") # => "otra cosa"
Fíjate en [[:alpha:]]: con \w no reconocería palabras como "Ñandú", porque \w solo acepta letras ASCII. "Ñandú café".scan(/\w+/) devuelve ["and", "caf"]; con [[:alpha:]]+ o \p{L}+ devuelve ["Ñandú", "café"].
Probar tu regex
Las expresiones regulares se leen mal y fallan en silencio: no dan error, simplemente coinciden con lo que no debían. Antes de fiarte de una, pruébala.
- En la consola. Abre
irby juega contexto[/patrón/]otexto.scan(/patrón/)hasta que devuelva lo que esperas. Para una prueba rápida sin abrir nada,ruby -e 'p "texto"[/patrón/]'. - En una web. Hay herramientas que dibujan el patrón y marcan las coincidencias. Tienes una comparativa en herramientas para probar expresiones regulares online. Comprueba el resultado final en Ruby, porque cada lenguaje tiene sus diferencias (como la
m). - Con un test. Si la regex va a tu código, deja escritos los casos que deben pasar y los que no.
Por ejemplo, con Minitest, que viene con Ruby:
require "minitest/autorun"
HORA = /\A([01]\d|2[0-3]):[0-5]\d\z/
class HoraTest < Minitest::Test
def test_acepta_horas_validas
assert_match HORA, "09:30"
assert_match HORA, "23:59"
end
def test_rechaza_horas_imposibles
refute_match HORA, "24:00"
refute_match HORA, "9:30"
refute_match HORA, "09:30\nborrar"
end
end
2 runs, 10 assertions, 0 failures, 0 errors, 0 skips
Los casos que deben fallar son los que más enseñan: el último solo pasa porque el patrón usa \A y \z. Si quieres empezar con los tests en Ruby, mira la introducción al testing en Ruby.
Límites
- Las regex sirven para patrones de texto, no para estructuras anidadas. Para leer HTML, JSON o CSV, usa un parser (como las librerías
jsonocsvde Ruby). - Un patrón mal escrito con muchas repeticiones anidadas puede tardar muchísimo con ciertos textos. Si aplicas regex a texto que viene de fuera, Ruby permite fijar un tiempo máximo con
Regexp.timeout=o conRegexp.new(patrón, timeout: segundos). - Si una regex necesita un párrafo para explicarse, plantéate dividirla o usar
/xcon comentarios.
Tu chuleta
| Quiero… | Uso… |
|---|---|
| Saber si aparece | texto.match?(/re/) |
| La posición | texto =~ /re/ |
| El texto que coincide | texto[/re/] |
| La coincidencia y sus grupos | m = texto.match(/re/) y m[:nombre] |
| Todas las coincidencias | texto.scan(/re/) |
| Cambiar la primera / todas | texto.sub(/re/, "x") / texto.gsub(/re/, "x") |
| Partir un texto | texto.split(/,\s*/) |
| Validar el texto entero | /\A…\z/ |
| Letras con tilde o ñ | [[:alpha:]] o \p{L} |
Y si las expresiones regulares te parecen un superpoder, no eres el único: echa un vistazo a la viñeta de expresiones regulares.
Fuentes
Documentación oficial de Ruby 4.0, consultada en noviembre de 2026:
- Regexp: metacaracteres, anclas
^,$,\A,\zy\Z,\wequivalente a[a-zA-Z0-9_],\sequivalente a[ \t\r\n\f\v], modificadoresi,myx, clases POSIX y Unicode, capturas con nombre asignadas a variables locales cuando la regex va antes de=~, quematch?no actualiza las variables globales yRegexp.timeout. - MatchData:
[],captures,named_captures,begin,pre_matchypost_match, y su equivalencia con$~,$&,$`y$'. - String:
=~,match,match?,scan(con y sin grupos),sub,gsubcon cadena, hash o bloque, ygsub!que devuelvenilsi no hay cambios.
Todos los ejemplos se han ejecutado con Ruby 4.0.9 en la imagen oficial de Docker (docker run --rm ruby:latest ruby ejemplos.rb), y la salida mostrada es la que devolvió. El test usa Minitest 6.0.0, incluido en esa imagen.