Regex para URLs: qué reconocer y qué dejar a un parser

“Regex de URL” suele significar una de dos cosas:

1. Encontrar URLs dentro de un bloque de texto, como una app de chat que vuelve clicables los enlaces.
2. Validar una entrada concreta, como el campo “Sitio web” de un formulario de perfil.

Necesitan patrones distintos, y el segundo es sobre todo trabajo para un parser de URLs. Este artículo cubre los dos, además de las trampas en las que cae la gente en cada caso. Todos los ejemplos son interactivos, así que edita los patrones y mira qué cambia.

01Encontrar URLs en un texto

La versión rápida es un esquema seguido de cualquier cosa que no sea un espacio:

\S+ se lo lleva todo hasta el siguiente espacio, y en un texto real una URL suele ir seguida de puntuación. Enlaza eso y quien lo lea se encontrará un 404.

02Quitar la puntuación final

La solución es decir cuál puede ser el último carácter. El cuerpo puede ser cualquier cosa salvo espacios, corchetes angulares y comillas. El carácter final, además, no puede ser un signo de puntuación habitual:

Funciona porque el codicioso [^\s<>"]* llega hasta el final de la URL y luego retrocede de carácter en carácter hasta que encaja la clase final. (Nuestro artículo sobre cuantificadores codiciosos y perezosos explica ese retroceso paso a paso.)

Aquí no hay una regla perfecta. Los enlaces de Wikipedia como https://en.wikipedia.org/wiki/Regex_(disambiguation) terminan de verdad en ), y este patrón lo recorta. Las bibliotecas que convierten texto en enlaces lo resuelven comprobando si los paréntesis están equilibrados, que es más lógica de la que debería cargar una sola regex.

Fíjate en que www.example.com no se encuentra, porque no tiene esquema. Si también quieres los enlaces que empiezan por www. a secas, empieza el patrón con (https?://|www\.).

03Validar una URL: las partes

Una URL web tiene hasta seis partes. Aquí están en https://regexhunter.com:443/blog/regex-urls?ref=home#top:

Parte	Ejemplo	¿Obligatoria?
esquema	https	sí
host	regexhunter.com	sí
puerto	:443	no
ruta	/blog/regex-urls	no
consulta	?ref=home	no
fragmento	#top	no

Un patrón que comprueba la forma de cada parte queda así:

Léelo parte por parte:

1. ^(https?):// el esquema, http o https, y el ://
2. ([^/:?#\s]+) el host: cualquier cosa hasta el siguiente /, :, ? o #
3. (:\d+)? un puerto opcional, solo dígitos
4. (/[^?#\s]*)? una ruta opcional, que empieza por /
5. (\?[^#\s]*)? una consulta opcional, que empieza por ?
6. (#\S*)?$ un fragmento opcional y luego el final

Es una buena comprobación de forma. Pero no dice nada sobre si el host tiene sentido. https://999.999.999.999 pasa, y https://- también. Podrías seguir añadiendo reglas para nombres de host, direcciones IP, corchetes de IPv6, usuarios y contraseñas, y dominios internacionales. Hay quien lo ha hecho, y el resultado ocupa cientos de caracteres.

04Deja que un parser haga el parseo

Todos los lenguajes habituales traen un parser de URLs que ya conoce esas reglas. En JavaScript (navegadores y Node), el constructor URL lanza una excepción con cualquier cosa que no pueda analizar:

function isHttpUrl(s) {
  try {
    const u = new URL(s);
    return u.protocol === 'http:' || u.protocol === 'https:';
  } catch {
    return false;
  }
}

new URL("https://exa mple.com"), new URL("https://999.999.999.999") y new URL("example.com") lanzan una excepción. La comprobación del protocolo importa: new URL("javascript:alert(1)") se analiza sin problema, y eso no lo quieres en un enlace.

Además obtienes las piezas gratis: u.hostname, u.port, u.pathname, u.search, u.hash y u.searchParams.get("x") para un valor de la consulta. Y la URL vuelve normalizada: HTTPS://Example.COM:443/a/../b se convierte en https://example.com/b.

En Python, urllib.parse.urlsplit divide una URL en las mismas partes:

from urllib.parse import urlsplit

u = urlsplit("http://localhost:3000/api?x=1#top")
(u.scheme, u.hostname, u.port, u.path, u.query, u.fragment)
# ('http', 'localhost', 3000, '/api', 'x=1', 'top')

Pero urlsplit divide, no valida. Casi nunca lanza un error. urlsplit("example.com") devuelve un esquema y un host vacíos con example.com como ruta, y urlsplit("https://exa mple.com") te dice sin inmutarse que el host es exa mple.com. Así que comprueba u.scheme in ("http", "https") y que u.netloc no esté vacío, y añade tus propias reglas para el host si las necesitas.

05Trampa: el punto sin escapar

En un patrón, . significa “cualquier carácter”. Olvida la barra invertida en un nombre de dominio y habrás admitido dominios que se le parecen:

Escribe www\.example\.com. Cada punto literal de un patrón necesita su barra invertida.

06Trampa: el final que falta

Esta importa en las comprobaciones de redirecciones y listas de permitidos, del tipo “solo devolver a la gente a URLs de nuestro propio sitio”:

El host tiene que acabar justo después de .com. Exige uno de los caracteres que pueden cerrarlo, o el final de la cadena:

Mejor aún para comprobaciones de seguridad: analiza con new URL() o urlsplit y luego compara el nombre de host con === o ==. Una comparación exacta de cadenas no tiene casos límite que olvidar.

07Pruébalo

Todos los monstruos son direcciones web. Los inocentes usan el esquema equivocado, un :// roto, una errata o ningún esquema:

08Lista de comprobación

• Para encontrar URLs en un texto: https?://[^\s<>"]*[^\s<>".,;:!?)], así la puntuación final se queda fuera.
• Para validar una URL: usa new URL() en JavaScript y comprueba el protocolo, o urlsplit en Python y comprueba el esquema y el host.
• Escapa cada punto literal: example\.com.
• En las listas de permitidos, ancla el principio y el final del host o, mejor, compara nombres de host ya analizados.
• Añade el modificador i si pueden aparecer mayúsculas. HTTPS://EXAMPLE.COM es una URL válida.

09Sigue practicando

• La ruta Validadores del mundo real de la Academia incluye slugs de URL, correos electrónicos, direcciones IP y más.
• La sección de escapado de la guía cubre las reglas de la barra invertida en las que se basa la trampa del punto.
• Prueba la caza de hoy o repasa tableros anteriores en el archivo.