Validador de IP Address Regex em Go

Introdução: O que é um Regex de IP Address?

Em Go, as expressões regulares (regex) oferecem uma forma poderosa de validar padrões como endereços IP. Os IPs são fundamentais em qualquer sistema baseado em rede, seja para armazenar informações de usuários, configurar firewalls ou construir aplicações web.

Os endereços IP existem em dois tipos:

• IPv4 (ex.: 192.168.1.1)

• IPv6 (ex.: 2001:0db8:85a3:0000:0000:8a2e:0370:7334)

Padrões Regex para IP Address

Padrão Regex para IPv4

^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$

Compatibilidade de Sabores Regex

Esses padrões regex para IPv4 funcionam em uma ampla variedade de motores de regex modernos, incluindo os usados em Go, Python, JavaScript, .NET, Java, Perl, Ruby e PCRE. Seja integrando validação em código backend, scripts ou APIs, você pode esperar que essas expressões se comportem de forma consistente na maioria dos ambientes de desenvolvimento.

Explicação:

• Valida 4 octetos separados por pontos.

• Cada octeto varia de 0 a 255.

• Exemplo de correspondência: 192.168.0.1

Notas Adicionais sobre Validação IPv4

Embora você possa encontrar padrões mais simples como:

^([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3}).([0-9]{1,3})$

esses correspondem a qualquer grupo de 1 a 3 dígitos separados por pontos, mas não restringem o intervalo a 0-255 para cada octeto. Isso significa que valores inválidos passariam, pois não são endereços IP válidos.

O regex acima é mais preciso porque garante que cada octeto esteja dentro do intervalo válido de IPv4. Esse padrão é suportado em sabores populares de regex, incluindo .NET, Java, JavaScript, PCRE, Perl, Python e Ruby.

Padrões Simples vs. Precisos para IPv4

Você pode encontrar dois tipos de expressões regulares ao validar endereços IPv4: padrões simples e precisos. É importante conhecer a diferença, especialmente se você se preocupa com qualidade dos dados.

Regex IPv4 Simples:
Um regex básico pode ser algo como ^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$. Ele verifica quatro grupos de 1 a 3 dígitos separados por pontos. É fácil de escrever, mas também corresponderá a endereços inválidos como 999.999.999.999 ou 256.100.100.100. Ou seja, verifica apenas a estrutura, não a validade de cada octeto.

Regex IPv4 Preciso:
Um padrão mais rigoroso garante que cada octeto esteja entre 0 e 255, capturando erros comuns. Por exemplo:
^(25[0-5]2[0-4]\d1\d\d[1-9]?\d)(\.(25[0-5]2[0-4]\d1\d\d[1-9]?\d)){3}$
Isso garante que entradas como 300.1.1.1 ou 256.256.256.256 sejam rejeitadas. É a melhor opção quando o objetivo é validação à prova de falhas (configurações de firewall, cadastro de usuários, etc.).

Em resumo:

• Regex simples: Rápido, mas permite endereços inválidos.

• Regex preciso: Ligeiramente mais complexo, mas garante que todos os endereços sejam realmente IPv4 válidos.

Extraindo Endereços IPv4 de Texto com Regex

Precisa extrair endereços IPv4 de logs brutos ou blocos de texto? As expressões regulares tornam essa tarefa direta e eficiente, sem varredura manual.

Padrão Rápido para Extração Básica

Para corresponder a qualquer sequência semelhante a um endereço IPv4 (independente de validade), use:

\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b

• \b garante correspondências de palavras completas.

• O padrão verifica quatro conjuntos de 1 a 3 dígitos separados por pontos.

Padrão Mais Rigoroso para Endereços Reais

Para extração mais precisa que retorna apenas endereços IPv4 sintaticamente válidos (cada octeto entre 0 e 255), use:

\b(?:(?:25[0-5]2[0-4][0-9]1\d\d[1-9]?\d)\.){3}
   (?:25[0-5]2[0-4][0-9]1\d\d[1-9]?\d)\b

• Esse padrão verifica os limites numéricos de cada octeto, reduzindo falsos positivos.

• Funciona nos principais motores de regex, incluindo Go, Python, JavaScript e PCRE.

Exemplo:
Dado Log: Tentativa falha de 192.168.99.120 ao meio-dia, o padrão mais rigoroso extrai 192.168.99.120.

Padrão Regex para IPv6

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Explicação:

• Corresponde a 8 grupos de números hexadecimais separados por dois-pontos.

• Cada grupo tem 1 a 4 dígitos hex.

• Exemplo de correspondência: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

Como Validar IPs em Go Usando Regex

Use o pacote integrado regexp do Go para compilar o padrão e testar strings:

package main
import (
"fmt"
"regexp"
)
func isValidIPv4(ip string) bool {
ipv4Pattern := ^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$
regex := regexp.MustCompile(ipv4Pattern)
return regex.MatchString(ip)
}
func isValidIPv6(ip string) bool {
ipv6Pattern := ^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$
regex := regexp.MustCompile(ipv6Pattern)
return regex.MatchString(ip)
}
func main() {
testIPs := []string{
"192.168.1.1",                    // IPv4 válido
"256.300.88.1",                   // IPv4 inválido
"2001:0db8:85a3:0000:0000:8a2e:0370:7334", // IPv6 válido
"2001:db8::1",                    // inválido (comprimido, não suportado aqui)
}
for _, ip := range testIPs {
    fmt.Printf("IP: %s | IPv4: %t | IPv6: %t\n", ip, isValidIPv4(ip), isValidIPv6(ip))
}

}

Opcional: Converter um Endereço IPv4 para Inteiro de 32 Bits

Após validar seu endereço IPv4, talvez seja necessário convertê-lo para um inteiro de 32 bits, por exemplo, para armazenamento eficiente, comparações rápidas ou trabalho com APIs de rede de baixo nível.

Veja como fazer isso em Go:

import (
"fmt"
"strconv"
"strings"
)
func ipv4ToInt(ip string) (uint32, error) {
octets := strings.Split(ip, ".")
if len(octets) != 4 {
return 0, fmt.Errorf("endereço IPv4 inválido")
}
var result uint32
for i := 0; i < 4; i++ {
octet, err := strconv.Atoi(octets[i])
if err != nil octet < 0 octet > 255 {
return 0, fmt.Errorf("octeto inválido no endereço IPv4")
}
result = (result << 8) uint32(octet)
}
return result, nil
}

Exemplo de uso:

ip := "192.168.1.1"
ipInt, err := ipv4ToInt(ip)
if err != nil {
fmt.Println("Erro:", err)
} else {
fmt.Printf("IPv4 %s como uint32: %d", ip, ipInt)
}

Casos de Uso da Validação de IP Address com Regex

• Rastreamento de IP de Usuários: Valide IPs antes de armazená-los em logs ou ferramentas de análise.

• Controle de Acesso: Permita apenas requisições de intervalos de IP autorizados.

• Configuração de Rede: Automatize a validação de IPs durante configuração ou provisionamento.

• Limpeza de Dados: Padronize conjuntos de dados com registros de IP malformados ou corrompidos.

Dicas Pro

• Use validação IPv6 apenas quando necessário, pois muitos sistemas ainda dependem principalmente de IPv4.

• O regex não valida IPs reservados ou locais (como 127.0.0.1 ou ::1), apenas o formato.

• Ao trabalhar com formatos IPv6 comprimidos (como ::1), considere usar o pacote net para análise completa.

• Use o Testador de Regex Go para ajustar seus padrões de IP e testar casos extremos.

Combine com Estas Ferramentas

Use o Validador de IP Address Regex em Go em fluxos de trabalho que também exijam:

• Validador de Regex de Senha em Go - Proteja credenciais de usuários

• Validador de Regex de Email em Go - Valide dados de contato com IPs

• Validador de Regex de URL em Go - Verifique URLs vinculadas a IPs

• Testador de Regex Go - Teste seus padrões de IP diretamente

• Validador de Regex de GUID em Go - Valide identificadores de recursos