Que es URL Regex en Go?

En Go (Golang), las expresiones regulares funcionan mediante el paquete integrado regexp. Un regex de URL es un patron usado para coincidir con enlaces web validos como https://example.com/path.

Use regex de Go para:

• Validar entradas de sitios web (enlaces, APIs)

• Limpiar URLs obtenidas por scraping

• Construir emparejadores de rutas en sistemas backend

• Analizar y extraer componentes de URLs

Metacaracteres Usados en URL Regex

• ^: Ancla el patron al inicio de la cadena.

• $: Ancla el patron al final de la cadena.

• .: Coincide con cualquier caracter excepto nueva linea.

• +: Uno o mas del token anterior.

• *: Cero o mas del token anterior.

• ?: Cero o uno del token anterior.

• []: Coincide con un caracter de un conjunto.

• (): Agrupa tokens.

• |: Actua como OR logico.

• \\: Escapa un metacaracter.

Como Funciona

1. Ingrese su patron regex de URL.

2. Pegue la cadena URL que desea validar.

3. Haga clic en "Validar" para comprobar si coincide.

4. Use "Probar otro" para repetir con diferentes ejemplos.

Ejemplo 1 - Validador Basico de URL en Go

Pruebe su logica regex completa usando el Probador de Regex Go.

package main
import (
"fmt"
"regexp"
)
func isValidURL(url string) bool {
var pattern = ^(http|https)://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:?#@!$&'()*+,;=]*)*$
urlRegex := regexp.MustCompile(pattern)
return urlRegex.MatchString(url)
}
func main() {
testURL := "https://www.example.com/search?q=test"
fmt.Println("Valid URL:", isValidURL(testURL))
}

Ejemplos:

• Entrada: "https://www.example.com/search?q=test"
  Salida: Valid URL: true
  Explicacion: La URL anterior esta correctamente formateada y coincide con el patron de validacion.

• Entrada: "https://www.example.com/ ,search"
  Salida: Valid URL: false
  Explicacion: Esta URL contiene un espacio despues de una coma, lo que la hace invalida segun el patron.

Ejemplo 2 - Coincidencia con URLs Acortadas

Tambien pruebe este patron en el Probador de Regex JavaScript si trabaja en validacion frontend.

var shortURL = "http://bit.ly/3abc"
var regex = regexp.MustCompile(^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-]*)?$)
fmt.Println("Valid short URL:", regex.MatchString(shortURL))

Ejemplos:

• Entrada: "http://bit.ly/3abc"
  Salida: Valid short URL: true
  Explicacion: Esta URL corta encaja en el patron para enlaces acortados.

• Entrada: "http://bit.ly/ 3abc"
  Salida: Valid short URL: false
  Explicacion: Un espacio despues del dominio hace que la validacion falle.

Ejemplo 3 - Verificar Barra Diagonal Final Opcional

Necesita un dominio o IP realista para pruebas? Use nuestro Generador de Nombres de Dominio o el Generador IPv4.

var urlWithSlash = "https://qodex.ai/"
var regex = regexp.MustCompile(^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/?$)
fmt.Println("URL has optional trailing slash:", regex.MatchString(urlWithSlash))

Ejemplos:

• Entrada: "https://qodex.ai/"
  Salida: true
  Explicacion: Esta URL termina con barra diagonal, lo cual el patron permite.

• Entrada: "https://qodex.ai"
  Salida: true
  Explicacion: La barra diagonal final es opcional, por lo que ambas formas son validas.

Complejidad Temporal y Espacial para Validacion de URL

• Complejidad Temporal: La validacion mediante regex es O(N), donde N es la longitud de la URL de entrada.

• Complejidad Espacial: No se necesita memoria adicional significativa, por lo que la complejidad espacial es O(1).

Consejos Profesionales para Usar URL Regex en Go

• Siempre ancle los patrones usando ^ y $ para evitar coincidencias parciales.

• Escape . como \. para coincidir con puntos literales en nombres de dominio.

• Use https? para permitir tanto HTTP como HTTPS.

• Use + para permitir multiples caracteres de ruta.

• Valide URLs completas incluyendo cadenas de consulta y rutas para verificacion robusta.

Casos de Uso Comunes

• Validacion de entrada en formularios (URLs enviadas por usuarios)

• Limpieza de salida de web scrapers

• Analisis de URLs de API

• Validacion de enlaces en CMS

• Validacion de rastreadores de campanas de marketing

Ejemplo - Validacion de URL en Python

Las expresiones regulares no son solo para Go. Si construye backends con Python, puede validar URLs con el modulo re en pocas lineas.

import re
def is_valid_url(url):
# Basic URL validation regex
pattern = r'^(https?://)?[a-zA-Z0-9.-]+.[a-zA-Z]{2,}(/[^\s]*)?$'
return re.match(pattern, url) is not None
Example usage
test_url = "https://www.example-site.org/path?query=123"
print("Valid URL:", is_valid_url(test_url))

• https?:// hace que el protocolo sea opcional o permite tanto HTTP como HTTPS.

• Los puntos estan escapados para que solo coincidan segmentos de dominio reales.

• Este patron permite rutas opcionales o cadenas de consulta despues del dominio raiz.

Validacion de URL en Java Usando Expresiones Regulares

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class URLValidator {
public static boolean isValidURL(String url) {
String regex = "^(https?://)(www\.)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/[a-zA-Z0-9-._~:/?#@!$&'()+,;=])?$";
Pattern pattern = Pattern.compile(regex);
if (url == null) return false;
Matcher matcher = pattern.matcher(url);
return matcher.matches();
}
public static void main(String[] args) {
    String testURL = "https://www.admin.google.com/";
    System.out.println("Is valid URL? " + isValidURL(testURL));
}

}

• El patron regex admite http y https, con o sin www.

• Coincide con nombres de dominio con extensiones estandar y permite caracteres de URL comunes en la ruta.

• Llame a isValidURL() con su cadena de entrada para verificar si coincide con el formato de URL esperado.

Combine con Estas Herramientas

• Validador Email Regex Go - Valide correos electronicos con regex

• Generador de Numero de Telefono - Obtenga numeros ficticios para pruebas de formularios

• Generador de Nombre de Usuario - Genere nombres de usuario de prueba para construir perfiles completos

• Generador de Nombres de Dominio - Uselo con URL regex para probar subdominios

• Generador de Contrasenas - Cree simulaciones de inicio de sesion completas