URL Regex Go Validator

O URL Regex Go Validator do Qodex ajuda desenvolvedores a testar e validar rapidamente se uma string é um link web válido usando expressões regulares em Go. Esta ferramenta é ideal para construir ou depurar aplicações Go que dependem de análise de links, validação de entrada ou web scraping. Combine-a com ferramentas como o Email Regex Go Validator, o Phone Number Regex Go Validator e o Go Regex Tester para criar uma lógica de validação robusta e segura.

URL Regex Go Validator - Documentação

O que é URL Regex em Go?

Em Go (Golang), as expressões regulares são fornecidas pelo pacote nativo regexp. Um regex de URL é um padrão usado para corresponder a links web válidos, como https://example.com/path.

Use regex em Go para:

Validar entradas de site (links, APIs)
Limpar URLs coletadas via scraping
Construir correspondentes de rota em sistemas backend
Analisar e extrair componentes de URLs

Metacaracteres Usados em URL Regex

^ : Ancora o padrão ao início da string.
$ : Ancora o padrão ao final da string.
. : Corresponde a qualquer caractere exceto nova linha.
+ : Um ou mais do token anterior.
* : Zero ou mais do token anterior.
? : Zero ou um do token anterior.
[] : Corresponde a um caractere de um conjunto.
() : Agrupa tokens.
| : Funciona como OR lógico.
\\ : Escapa um metacaractere.

Como Funciona

Insira seu padrão regex de URL.
Cole a string de URL que você quer validar.
Clique em "Validar" para verificar se ela corresponde.
Use "Tentar Outro" para repetir com exemplos diferentes.

Exemplo 1 - Validador de URL Básico em Go

Teste sua lógica completa de regex usando o Go Regex Tester.

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))
}

Exemplos:

Entrada: "https://www.example.com/search?q=test"
Saída: Valid URL: true
Explicação: A URL acima está formatada corretamente e corresponde ao padrão de validação.
Entrada: "https://www.example.com/ ,search"
Saída: Valid URL: false
Explicação: Esta URL contém um espaço após uma vírgula, o que a torna inválida de acordo com o padrão.

Exemplo 2 - Correspondência de URLs Encurtadas

Teste também esse padrão no JavaScript Regex Tester se você estiver trabalhando com validação no 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))

Exemplos:

Entrada: "http://bit.ly/3abc"
Saída: Valid short URL: true
Explicação: Esta URL encurtada se encaixa no padrão para links abreviados.
Entrada: "http://bit.ly/ 3abc"
Saída: Valid short URL: false
Explicação: Um espaço após o domínio causa falha na validação.

Dica: Seja construindo um backend em Go ou um frontend em JavaScript, sempre adapte suas expressões regulares ao formato de entrada esperado e teste exaustivamente com exemplos reais, como URLs encurtadas do Bitly, TinyURL ou serviços similares.

Exemplo 3 - Verificar Barra Final Opcional

Precisa de um domínio ou IP realista para testes? Use nosso Gerador de Nome de Domínio ou Gerador 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))

Exemplos:

Entrada: "https://qodex.ai/"
Saída: true
Explicação: Esta URL termina com barra final, que é permitida pelo padrão.
Entrada: "https://qodex.ai"
Saída: true
Explicação: A barra final é opcional, então ambas as formas são válidas.

Complexidade de Tempo e Espaço para Validação de URL

A validação de URL usando expressões regulares é altamente eficiente:

Complexidade de Tempo: Como cada caractere na string é examinado uma vez pelo mecanismo regex, a complexidade de tempo é tipicamente O(N), onde N é o comprimento da URL de entrada.
Complexidade de Espaço: Nenhuma memória extra significativa é necessária além de algumas variáveis; portanto, a complexidade de espaço é O(1).

Em resumo, verificações de URL baseadas em regex são rápidas e leves, mesmo para URLs mais longas. Isso as torna uma solução sólida para tudo, desde verificações de formulários instantâneas até ferramentas de análise de dados em grande escala.

Dicas Profissionais para Usar URL Regex em Go

Sempre ancore padrões usando ^ e $ para evitar correspondências parciais.
Escape . como \. para corresponder a pontos literais em nomes de domínio.
Use https? para permitir ambos os protocolos HTTP e HTTPS.
Use + para permitir múltiplos caracteres de caminho.
Valide URLs completas incluindo query strings e caminhos para verificação robusta.

Casos de Uso Comuns

Validação de entrada de formulário (URLs enviadas pelo usuário)
Limpeza de saída de web scrapers
Análise de URL de API
Validação de links em CMS
Validação de rastreador de campanha de marketing

Exemplo - Validação de URL em Python

Expressões regulares não são exclusivas do Go! Se você está construindo backends em Python, pode validar URLs com o módulo re em apenas algumas linhas.

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))

Alguns pontos a lembrar:

O https?:// torna o protocolo opcional ou permite tanto HTTP quanto HTTPS.
Os pontos são escapados para garantir que apenas segmentos reais de domínio correspondam.
Esse padrão permite caminhos ou query strings opcionais após o domínio raiz.
Para validação muito estrita (incluindo portas, IPs, domínios Unicode, etc.), você pode expandir o regex ou usar bibliotecas dedicadas como validators ou urllib.parse.

Validação de URL em Java com Expressões Regulares

Se você está trabalhando em Java e precisa confirmar se uma string é uma URL corretamente formatada, pode usar as classes Pattern e Matcher do pacote java.util.regex.

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class URLValidator {
public static boolean isValidURL(String url) {
// Basic URL regex for http/https with optional www and path
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));
}

}

Como funciona:

O padrão regex suporta http e https, com ou sem www.
Ele corresponde a nomes de domínio com extensões padrão e permite caracteres comuns de URL no caminho.
Basta chamar isValidURL() com sua string de entrada para verificar se ela corresponde ao formato de URL esperado.

Combine com Estas Ferramentas

Email Regex Go Validator - Valide emails com regex
Gerador de Número de Telefone - Obtenha números simulados para testes de formulário
Gerador de Nome de Usuário - Gere nomes de usuário de teste para criar perfis completos de teste
Gerador de Nome de Domínio - Use com regex de URL para testar subdomínios
Gerador de Senha - Crie simulações completas de login