Nivel inicial14 min de lectura · Publicado el

Expresiones regulares en Ruby: =~, match, scan y gsub

Expresiones regulares en Ruby: una descripción, gafas, pelo corto y camiseta roja, que solo cumple una persona de la multitud. Regex: describe, no nombrarubentejera.com busco: gafas, pelo corto, camiseta roja/\d\d:\d\d:\d\d/"Son las 12:34:56" → "12:34:56"
La descripción es la regex: no dice quién es, sino cómo es, y solo coincide quien lo cumple todo. Igual, /\d\d:\d\d:\d\d/ describe la forma de una hora: dos dígitos, dos puntos… y encuentra 12:34:56.

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.

  1. En la consola. Abre irb y juega con texto[/patrón/] o texto.scan(/patrón/) hasta que devuelva lo que esperas. Para una prueba rápida sin abrir nada, ruby -e 'p "texto"[/patrón/]'.
  2. 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).
  3. 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 json o csv de 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 con Regexp.new(patrón, timeout: segundos).
  • Si una regex necesita un párrafo para explicarse, plantéate dividirla o usar /x con 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, \z y \Z, \w equivalente a [a-zA-Z0-9_], \s equivalente a [ \t\r\n\f\v], modificadores i, m y x, clases POSIX y Unicode, capturas con nombre asignadas a variables locales cuando la regex va antes de =~, que match? no actualiza las variables globales y Regexp.timeout.
  • MatchData: [], captures, named_captures, begin, pre_match y post_match, y su equivalencia con $~, $&, $` y $'.
  • String: =~, match, match?, scan (con y sin grupos), sub, gsub con cadena, hash o bloque, y gsub! que devuelve nil si 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.