Validador de Regex de Número de Telefone em Go

Use o Validador de Regex de Número de Telefone em Go para testar e validar formatos de número de telefone usando o pacote regexp do Golang. Esta ferramenta é ideal para desenvolvedores e testers que criam fluxos de cadastro, validações de formulários ou aplicações de telecom. Verifique instantaneamente se seu regex corresponde corretamente a números de celular, formatos internacionais ou padrões específicos de dígitos, sem precisar escrever código extra.

Precisa de mais entradas de teste? Experimente nosso Gerador de Número de Telefone, Gerador de CEP ou Gerador de Endereço para simular dados reais de formulários.

Validador de Regex de Número de Telefone em Go - Documentação

O que é Regex de Número de Telefone em Go?

Em Go (Golang), expressões regulares são tratadas pela biblioteca padrão regexp. Validar números de telefone envolve verificar estruturas específicas como:

Códigos de país (ex.: +91, +1)
Códigos de área
Separadores opcionais como hifens, espaços ou parênteses
Comprimentos variáveis dependendo do país ou região

O regex de número de telefone é especialmente útil em:

Validações de formulários durante cadastros de usuários
Verificações de backend em APIs ou bancos de dados
Sistemas de comunicação por SMS ou chamadas
Softwares de telecom e aplicativos móveis

Recursos e Construtos Principais (Regex em Go)

Metacaracteres

.: Corresponde a qualquer caractere exceto nova linha. Exemplo: /.23/ corresponde a "a23", "x23"
^: Ancora no início da string. Exemplo: /^+91/ corresponde a "+91xxxxx..."
$: Ancora no final da string. Exemplo: /123$/ corresponde ao final "123"
|: Age como OU. Exemplo: /landline|mobile/ corresponde a qualquer das palavras

Classes de Caracteres

[0-9]: Corresponde a qualquer dígito de 0 a 9
[^0-9]: Corresponde a qualquer caractere não dígito
[a-zA-Z]: Corresponde a qualquer letra (minúscula ou maiúscula)

Classes Predefinidas

\d: Corresponde a um dígito. Equivalente a [0-9]
\D: Corresponde a um caractere não dígito
\s: Corresponde a um espaço em branco
\S: Corresponde a qualquer caractere não espaço

Quantificadores

*: Corresponde a zero ou mais ocorrências
+: Corresponde a uma ou mais ocorrências
?: Corresponde a zero ou uma (opcional)
{n}: Corresponde exatamente n vezes
{n,}: Corresponde pelo menos n vezes
{n,m}: Corresponde entre n e m vezes

Limitando o Número de Correspondências

Para que sua busca com regex em Go retorne apenas um número limitado de correspondências, passe um inteiro não negativo como segundo argumento para funções como FindAllString ou FindAllStringSubmatch. Por exemplo, usar FindAllString("peach punch pinch", 2) retornará apenas as duas primeiras correspondências encontradas.

Isso é útil quando você precisa apenas de um subconjunto de resultados, como os primeiros números de telefone de um bloco de texto longo.

Exemplo de Padrão Regex para Números de Telefone

Um padrão regex comum para validar números de telefone internacionais:

^\+?[1-9]\d{1,3}?[-.\s]?\(?\d{1,4}?\)?[-.\s]?\d{1,9}([-.\s]?\d{1,9})?$

Este padrão corresponde a:

Códigos de país como +91, +44, +1
Separadores opcionais como hifens, pontos e espaços
Parênteses ao redor de códigos de área

Métodos Comuns dos Objetos regexp em Go

Após compilar uma expressão regular com o pacote regexp do Go, um conjunto de métodos úteis fica disponível para correspondência, busca, extração e transformação de strings. Veja os principais:

MatchString / Match: Verifica rapidamente se o padrão corresponde a parte ou toda uma string. Ideal para validações básicas de formato de telefone.
FindString / Find: Retorna a primeira substring que corresponde ao padrão.
FindStringIndex / FindIndex: Retorna as posições de início e fim da primeira correspondência.
FindStringSubmatch / FindSubmatch: Captura a correspondência principal e os grupos de captura definidos no padrão.
FindStringSubmatchIndex / FindSubmatchIndex: Como o anterior, mas retorna índices para todos os grupos capturados.
Variantes "All" (ex.: FindAllString, FindAllStringSubmatch, etc.): Varrem a entrada inteira e retornam todas as correspondências. Você pode limitar o número de resultados passando um contador.
ReplaceAllString / ReplaceAll: Substitui eficientemente todas as substrings correspondentes por outro valor.
ReplaceAllFunc: Aplica uma função a cada correspondência, permitindo transformar o texto de forma dinâmica.

Ao armazenar padrões regex em variáveis globais, use MustCompile em vez de Compile. Isso garante que o padrão seja válido na inicialização do programa e causará um panic se houver erro de sintaxe, ajudando a identificar problemas cedo.

Exemplos de Código em Go

Exemplo 1: Validação Básica de Telefone

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^\+?[0-9]{10,15}$)
phone := "+14155552671"
fmt.Println("Valid Phone:", pattern.MatchString(phone))
}

Teste padrões similares no Go Regex Tester

Exemplo 2: Números de Telefone com Separadores

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^$begin:math:text$?\\d{3}$end:math:text$?[-.\s]?\d{3}[-.\s]?\d{4}$)
phone := "(415) 555-2671"
fmt.Println("Valid Format:", pattern.MatchString(phone))
}

Gere números reais com o Gerador de Número de Telefone

Exemplo 3: Teste de Campo de Formulário com Código de Área

package main
import (
"fmt"
"regexp"
)
func main() {
input := "+91-9876543210"
regex := regexp.MustCompile(^\+91[-\s]?[6-9]\d{9}$)
fmt.Println("Indian Mobile Number Valid:", regex.MatchString(input))
}

Combine com o Gerador de Endereço para dados completos de usuário de teste.

Obtendo Índices de Correspondências em Go

Para recuperar as posições exatas de início e fim das correspondências e subcorrespondências em uma string, use o método FindStringSubmatchIndex:

fmt.Println(r.FindStringSubmatchIndex("peach punch"))

Isso retorna um slice de inteiros indicando os índices de bytes para a correspondência geral, seguida pelos grupos de captura. É semelhante ao método span() do módulo re do Python.

Encontrando a Primeira Correspondência em uma String

Para obter a primeira substring que corresponde ao seu regex, use o método FindString():

pattern := regexp.MustCompile([a-zA-Z]+)
result := pattern.FindString("peach punch")
// result será "peach"

Retorna o primeiro trecho da entrada que corresponde ao padrão. Se não houver correspondência, retorna uma string vazia. Experimente diferentes entradas no Go Regex Tester.

Substituindo Substrings com Regex em Go

Substituição Básica com ReplaceAllString

Para remover todas as ocorrências de uma palavra, como substituir "peach" por uma string vazia:

package main
import (
"fmt"
"regexp"
)
func main() {
r := regexp.MustCompile(peach)
result := r.ReplaceAllString("a peach", "")
fmt.Println(result) // Saída: a
}

Avançado: Substituição com Funções Personalizadas

O ReplaceAllFunc permite transformar cada correspondência como você desejar:

package main
import (
"bytes"
"fmt"
"regexp"
)
func main() {
r := regexp.MustCompile([a-z]+)
text := []byte("a peach")
result := r.ReplaceAllFunc(text, bytes.ToUpper)
fmt.Println(string(result)) // Saída: A PEACH
}

Trabalhando com Byte Slices no Regex em Go

Os métodos de regex em Go são flexíveis e também operam em byte slices ([]byte). Use Match() em vez de MatchString() quando seus dados estiverem armazenados como []byte:

pattern := regexp.MustCompile(peach)
text := []byte("peach")
fmt.Println("Matches byte slice:", pattern.Match(text))

Dicas Profissionais

Sempre use regexp.MustCompile() para padrões estáticos e evitar erros em tempo de execução.
Use FindStringSubmatch() para extrair partes como códigos de área ou ramais.
Evite expressões muito greedy como .*, prefira quantificadores como {10,15} para maior precisão.
Valide com dados reais de ferramentas como o Gerador de Número de Telefone ou Gerador de Nome de Usuário.
Use o prefixo (?i) para correspondência case-insensitive quando necessário.