Validador Regex de Números em Go

Teste padrões numéricos usando o Go Regex Tester, criado para desenvolvedores e testadores. Este Validador Regex de Números em Go ajuda a validar inteiros, formatos decimais e padrões numéricos como "1.000" ou "3,14". Combine com ferramentas como o Gerador de Senha, Gerador de Nome de Usuário ou Gerador de Email para simular dados de formulário completos.

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

O que é Regex de Números?

Em Go (Golang), números podem ser validados usando expressões regulares via o pacote regexp embutido. Essas expressões ajudam a verificar padrões como inteiros ou campos que aceitam apenas dígitos.

O regex em Go é frequentemente usado para:

Validar campos de formulário como idade, IDs e quantidades
Extrair ou corresponder sequências numéricas em texto
Limpar dados filtrando entradas numéricas inválidas

Padrão Regex para Inteiros Decimais

Para corresponder inteiros decimais que podem incluir um sinal de mais (+) ou menos (-) opcional no início, use a seguinte expressão regular:

[+-]?\b[0-9]+\b

Como funciona:

[+-]?: corresponde a um sinal de mais ou menos opcional no início.
\b: limite de palavra que garante a correspondência de números inteiros, não de números embutidos em palavras.
[0-9]+: corresponde a um ou mais dígitos.

Este padrão é suportado em sabores populares, incluindo .NET, Java, JavaScript, PCRE, Perl, Python e Ruby.

Regex para Inteiros com Sinal

Para corresponder uma string que contém apenas um inteiro (com sinal de mais ou menos opcional), use:

^[+-]?[0-9]+$

^ afirma o início da string.
[+-]? permite um sinal "+" ou "-" opcional.
[0-9]+ corresponde a um ou mais dígitos.
$ garante a correspondência da string inteira, não apenas de uma parte dela.

Este padrão valida números como "42", "-17" ou "+100", mas rejeita strings com letras, espaços ou decimais.

Verificando Strings de Inteiros Positivos

Para verificar que uma string consiste exclusivamente em um inteiro positivo em notação decimal (sem sinal negativo, sem decimais), use:

^[0-9]+$

Este padrão garante que a string:

Começa (^) e termina ($) com um ou mais dígitos ([0-9]+)
Contém apenas dígitos, sem caracteres extras ou espaços

Este regex funciona na maioria dos sabores, incluindo Python, Java, JavaScript, Go, Perl e Ruby.

Padrões Regex Comuns para Números:

^\d+$: Corresponde a um inteiro positivo (ex.: 12345)
^\d+\.\d+$: Corresponde a um número decimal (ex.: 3.14, 0.75)
^\d{1,3}(,\d{3})*$: Corresponde a números formatados com vírgulas (ex.: 1,000 ou 100,000)
^-?\d+$: Corresponde a inteiros com sinal de menos opcional (ex.: -42)
^-?\d+\.\d+$: Corresponde a decimais com sinal (ex.: -3.14)

Exemplos com Código Go

Exemplo 1: Validar Inteiros

Experimente no Go Regex Tester

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^\d+$)
input := "45678"
isValid := pattern.MatchString(input)
fmt.Printf("Is '%s' a valid integer? %t\n", input, isValid)
}

Exemplo 2: Corresponder Números Decimais

Use junto com o Gerador de Número de Telefone para simular formulários de entrada completos.

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^\d+\.\d+$)
input := "123.45"
isValid := pattern.MatchString(input)
fmt.Printf("Is '%s' a valid decimal? %t\n", input, isValid)
}

Exemplo 3: Corresponder Preços Formatados

Combine com o Gerador de CEP para validação de dados de e-commerce.

package main
import (
"fmt"
"regexp"
)
func main() {
pattern := regexp.MustCompile(^\d{1,3}(,\d{3})*$)
input := "12,345"
isValid := pattern.MatchString(input)
fmt.Printf("Is '%s' a valid formatted number? %t\n", input, isValid)
}

Encontrando Inteiros Decimais Positivos com Regex

Precisa identificar inteiros positivos isolados em um bloco de texto? As expressões regulares têm a solução. Há alguns padrões confiáveis que você pode usar dependendo da linguagem-alvo.

Padrão Básico: Corresponder Números Isolados

\b[0-9]+\b

\b corresponde a um limite de palavra, garantindo a captura apenas de números inteiros.
[0-9]+ corresponde a um ou mais dígitos.

Este padrão funciona na maioria dos principais mecanismos de regex: .NET, JavaScript, Python, Java, PCRE, Perl e Ruby.

Adaptando para Diferentes Linguagens

Algumas linguagens têm peculiaridades com lookbehind. Por exemplo:

Linguagens como .NET e Java suportam lookbehinds, então você pode usar algo como:
```
(?<=^\s)[0-9]+(?=$\s)
```
Para Python e Perl, como lookbehinds precisam de padrões de largura fixa, ajuste para:
```
(?:^(?<=\s))[0-9]+(?=$\s)
```

Dicas Avançadas

Use MustCompile em Go para padrões regex reutilizáveis.
Para decimais opcionais, use ^\d+(.\d+)?$.
Sempre ancore o padrão com ^ e $ para correspondência completa.
Evite padrões excessivamente permissivos; teste casos extremos como 0001, -0.0, etc.

Como Funciona

Cole o padrão regex de número ou use um predefinido.
Insira o número de teste no campo.
Veja instantaneamente se há correspondência.
Ajuste e refine o padrão em tempo real.

Casos de Uso

Validação de formulários para IDs de usuário, idade ou campos de preço
Limpeza de dados para importações de CSV com colunas numéricas
Tratamento de entradas em software corporativo (faturamento, notas fiscais, etc.)
Cenários de teste de QA para entradas de casos extremos
Totais simulados de pedidos de e-commerce

Combine com Estas Ferramentas

Go Regex Tester: Teste padrões regex completos em Go com feedback em tempo real.
Gerador de Email: Crie emails realistas para validações de formulário.
Gerador de Número de Telefone: Combine com validação numérica para campos de cadastro.
Gerador de Senha: Valide regras de senha numérica ou alfanumérica.
Gerador de Nome de Usuário: Gere perfis de teste completos.