Gerador de Regex

Gerador de Regex - Construtor Visual de Expressões Regulares e Testador

Um poderoso gerador e testador de regex online com construtor visual de padrões. Crie, teste e depure expressões regulares com feedback instantâneo. Inclui biblioteca abrangente de padrões, inserção rápida de componentes, destaque de sintaxe, visualização de correspondências e geração de código para JavaScript, Python, PHP, Java, Ruby e Go.

O que são Expressões Regulares?

**Expressões Regulares (Regex)** são ferramentas poderosas de correspondência de padrões usadas para buscar, validar e manipular texto.

**Usos Comuns:**

1. **Validação:**
• Endereços de email
• Números de telefone
• Senhas
• URLs
• Cartões de crédito

2. **Processamento de Texto:**
• Buscar e substituir
• Extração de dados
• Análise de logs
• Limpeza de texto

3. **Validação de Dados:**
• Entradas de formulário
• Parâmetros de API
• Formatos de arquivo
• Arquivos de configuração

**Sintaxe Básica:**

• **Literais:** Casam caracteres exatos
- `abc` casa "abc"

• **Classes de Caracteres:**
- `\d` = dígito (0-9)
- `\w` = caractere de palavra (a-z, A-Z, 0-9, _)
- `\s` = espaço em branco
- `.` = qualquer caractere

• **Quantificadores:**
- `*` = 0 ou mais
- `+` = 1 ou mais
- `?` = 0 ou 1 (opcional)
- `{n}` = exatamente n vezes
- `{n,m}` = entre n e m vezes

• **Âncoras:**
- `^` = início da linha
- `$` = fim da linha
- `\b` = limite de palavra

• **Grupos:**
- `(...)` = grupo de captura
- `(?:...)` = grupo sem captura

• **Conjuntos de Caracteres:**
- `[abc]` = casa a, b ou c
- `[a-z]` = casa qualquer letra minúscula
- `[^abc]` = casa qualquer coisa exceto a, b ou c

**Exemplos:**

```regex
# Validação de email
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

# Número de telefone (EUA)
^\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})$

# URL
^https?:\/\/[\w\-]+(\.[\w\-]+)+[/#?]?.*$

# Senha forte
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
```

Como usar este Gerador de Regex?

**Guia Passo a Passo:**

**1. Escolha um Ponto de Partida:**

**Opção A - Biblioteca de Padrões:**
• Navegue pelos padrões comuns (email, URL, telefone, etc.)
• Clique em um padrão para carregá-lo
• Modifique conforme necessário

**Opção B - Construir do Zero:**
• Digite o padrão diretamente na entrada
• Use Componentes Rápidos para inserir sintaxe
• Clique nos componentes para adicionar na posição do cursor

**2. Defina as Flags:**

• **g (Global):** Encontra todas as correspondências, não apenas a primeira
• **i (Ignorar Maiúsculas):** Ignora maiúsculas/minúsculas (A = a)
• **m (Multilinha):** ^ e $ casam quebras de linha
• **s (Ponto Casa Tudo):** . casa novas linhas

**3. Teste Seu Padrão:**

• Digite texto de teste na área Entrada de Teste
• Clique em "Testar Padrão"
• Veja correspondências destacadas em tempo real
• Veja contagem e posições de correspondências
• Inspecione grupos capturados

**4. Entenda Seu Padrão:**

• Clique em "Explicar Padrão"
• Veja decomposição de cada componente
• Aprenda o que cada símbolo significa
• Entenda a estrutura do padrão

**5. Gere Código:**

• Clique em "Gerar Código"
• Obtenha código pronto para usar em:
- JavaScript
- Python
- PHP
- Java
- Ruby
- Go
• Copie para seu projeto

**Dicas:**

✓ Comece com um exemplo da biblioteca de padrões
✓ Teste com múltiplas variações de entrada
✓ Use Explicar para aprender sintaxe
✓ Teste casos extremos
✓ Mantenha padrões simples quando possível
✓ Use grupos sem captura (?:) para performance
✓ Escape caracteres especiais: \. \* \+ \? etc.

Padrões Regex Comuns e Casos de Uso

**Padrões de Validação:**

**1. Endereço de Email:**
```regex
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
```
• Validação básica de email
• Permite caracteres especiais comuns
• Requer @ e extensão de domínio

**2. URL (HTTP/HTTPS):**
```regex
^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)$
```
• Casa URLs web
• Prefixo www opcional
• Suporta query strings e âncoras

**3. Números de Telefone:**
```regex
# Formato EUA
^\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})$

# Internacional
^\+?[1-9]\d{1,14}$
```

**4. Senha Forte:**
```regex
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
```
• Mínimo 8 caracteres
• Pelo menos uma letra maiúscula
• Pelo menos uma letra minúscula
• Pelo menos um dígito
• Pelo menos um caractere especial

**Extração de Dados:**

**5. Formatos de Data:**
```regex
# YYYY-MM-DD (ISO)
^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])$

# DD/MM/YYYY
^(?:0[1-9]|[12][0-9]|3[01])\/(?:0[1-9]|1[0-2])\/\d{4}$

# MM-DD-YYYY
^(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])-\d{4}$
```

**6. Endereços IP:**
```regex
# IPv4
^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

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

**7. Cartão de Crédito:**
```regex
# Visa, MasterCard, Amex, Discover
^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|6(?:011|5[0-9][0-9])[0-9]{12})$
```

**Processamento de Texto:**

**8. Extrair Hashtags:**
```regex
#[a-zA-Z0-9_]+
```

**9. Extrair Menções:**
```regex
@[a-zA-Z0-9_]+
```

**10. Tags HTML:**
```regex
<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)
```

**11. Remover Espaços Extras:**
```regex
\s+
# Substituir por espaço único
```

**Padrões de Código:**

**12. Variáveis JavaScript:**
```regex
(var|let|const)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=
```

**13. Códigos de Cor Hex:**
```regex
^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$
```

**14. Extensões de Arquivo:**
```regex
\.(jpg|jpeg|png|gif|pdf|doc|docx)$
```

**Dicas:**

• Teste padrões com casos extremos
• Use testadores de regex online para depuração
• Considere performance para textos grandes
• Mais simples é geralmente melhor
• Documente padrões complexos

Flags de Regex Explicadas

**Flags de Expressão Regular:**

Flags modificam como o motor de regex processa padrões.

**1. Flag Global (g):**

```javascript
const texto = 'gato pato rato';
const regex1 = /ato/; // Sem global
const regex2 = /ato/g; // Global

texto.match(regex1); // ['ato'] - apenas primeira correspondência
texto.match(regex2); // ['ato', 'ato', 'ato'] - todas as correspondências
```

**Use quando:**
• Encontrar todas as ocorrências
• Substituir todas as instâncias
• Contar correspondências

**2. Flag Ignorar Maiúsculas (i):**

```javascript
const regex1 = /ola/; // Sensível a maiúsculas
const regex2 = /ola/i; // Insensível a maiúsculas

regex1.test('Ola'); // false
regex2.test('Ola'); // true
regex2.test('OLA'); // true
```

**Use quando:**
• Validação de entrada do usuário
• Busca insensível a maiúsculas
• Correspondência flexível

**3. Flag Multilinha (m):**

```javascript
const texto = `linha 1
linha 2
linha 3`;

const regex1 = /^linha/; // Casa início da string
const regex2 = /^linha/m; // Casa início de cada linha

texto.match(regex1); // ['linha'] - uma correspondência
texto.match(regex2); // ['linha', 'linha', 'linha'] - três correspondências
```

**Efeito:**
• `^` casa início de cada linha (não apenas string)
• `$` casa fim de cada linha (não apenas string)

**Use quando:**
• Processar texto multilinha
• Validação linha por linha
• Análise de arquivos de log

**4. Flag Ponto Casa Tudo (s):**

```javascript
const texto = 'ola\nmundo';

const regex1 = /ola.mundo/; // . não casa \n
const regex2 = /ola.mundo/s; // . casa tudo

regex1.test(texto); // false
regex2.test(texto); // true
```

**Efeito:**
• `.` casa caracteres de nova linha
• Normalmente `.` casa qualquer coisa exceto `\n`

**Use quando:**
• Casar entre linhas
• Análise HTML/XML
• Extração de conteúdo multilinha

**Combinações de Flags:**

```javascript
// Múltiplas flags juntas
const regex = /padrao/gim;
// g = global
// i = ignorar maiúsculas
// m = multilinha

// Combinações comuns:
/email/gi // Encontrar todos os emails, qualquer maiúscula
/^erro/gim // Encontrar todas as linhas começando com "erro", qualquer maiúscula
/.*?/gs // Casar tudo entre linhas, preguiçosamente
```

**Flags Específicas de Linguagem:**

**JavaScript:**
```javascript
/padrao/gimsuy
// y = sticky (casa de lastIndex)
// u = unicode (tratamento adequado de unicode)
```

**Python:**
```python
import re
re.IGNORECASE # i
re.MULTILINE # m
re.DOTALL # s
re.VERBOSE # x - ignora espaços, permite comentários
```

**PHP:**
```php
/padrao/gimsx
// x = estendido (ignora espaços)
```

**Melhores Práticas:**

✓ Use apenas flags que precisa
✓ Flag global para operações de substituir/contar
✓ Ignorar maiúsculas para entrada do usuário
✓ Multilinha para processamento de texto
✓ Teste com e sem flags
✓ Documente uso de flags em comentários do código

Técnicas Avançadas de Regex

**1. Lookahead e Lookbehind:**

**Lookahead Positivo (?=...)**
```regex
# Casa 'foo' apenas se seguido por 'bar'
foo(?=bar)

# Casa: 'foo' em 'foobar'
# Não casa: 'foo' em 'foobaz'
```

**Lookahead Negativo (?!...)**
```regex
# Casa 'foo' apenas se NÃO seguido por 'bar'
foo(?!bar)

# Casa: 'foo' em 'foobaz'
# Não casa: 'foo' em 'foobar'
```

**Lookbehind Positivo (?<=...)**
```regex
# Casa 'bar' apenas se precedido por 'foo'
(?<=foo)bar

# Casa: 'bar' em 'foobar'
# Não casa: 'bar' em 'bazbar'
```

**Lookbehind Negativo (?<!...)**
```regex
# Casa 'bar' apenas se NÃO precedido por 'foo'
(?<!foo)bar

# Casa: 'bar' em 'bazbar'
# Não casa: 'bar' em 'foobar'
```

**2. Grupos de Captura:**

```regex
# Extrair partes de uma data
(\d{4})-(\d{2})-(\d{2})

# Casa: '2025-01-15'
# Grupo 1: '2025' (ano)
# Grupo 2: '01' (mês)
# Grupo 3: '15' (dia)
```

**Grupos de Captura Nomeados:**
```regex
(?<ano>\d{4})-(?<mes>\d{2})-(?<dia>\d{2})

# Acesse por nome no código:
# match.groups.ano
# match.groups.mes
# match.groups.dia
```

**Grupos Sem Captura (?:...)**
```regex
# Grupo para alternação, mas não captura
(?:gato|cachorro)s?

# Casa: gato, gatos, cachorro, cachorros
# Não cria grupo de captura
# Melhor performance
```

**3. Referências Retroativas:**

```regex
# Casar palavras repetidas
\b(\w+)\s+\1\b

# Casa: 'o o', 'ola ola'
# \1 refere-se ao primeiro grupo capturado
```

**Casamento de Tags HTML:**
```regex
# Casar tags de abertura e fechamento
<([a-z]+)>.*?</\1>

# Casa: <div>conteudo</div>
# Não casa: <div>conteudo</span>
```

**4. Quantificadores Gananciosos vs Preguiçosos:**

**Ganancioso (padrão):**
```regex
# Casa o máximo possível
<.*>

# Em: '<div>Ola</div> <span>Mundo</span>'
# Casa: '<div>Ola</div> <span>Mundo</span>' (string inteira)
```

**Preguiçoso (adicione ?):**
```regex
# Casa o mínimo possível
<.*?>

# Em: '<div>Ola</div> <span>Mundo</span>'
# Casa: '<div>', '</div>', '<span>', '</span>' (separadamente)
```

**Quantificadores preguiçosos:**
• `*?` = 0 ou mais (preguiçoso)
• `+?` = 1 ou mais (preguiçoso)
• `??` = 0 ou 1 (preguiçoso)
• `{n,m}?` = n a m (preguiçoso)

**5. Grupos Atômicos (?>...)**

```regex
# Prevenir backtracking
(?>\d+)\.

# Mais eficiente para números longos
# Não tenta novamente se ponto decimal não casar
```

**6. Padrões Condicionais:**

```regex
# Se grupo 1 casou, use padrão A, senão padrão B
(\()?[^()]+(?(1)\))

# Casa: 'ola' ou '(ola)'
# Não casa: 'ola)' ou '(ola'
```

**7. Propriedades Unicode:**

```regex
# Casar qualquer letra (qualquer idioma)
\p{L}+

# Casar emoji
\p{Emoji}

# Casar símbolos de moeda
\p{Sc}
```

**Dicas de Performance:**

✓ Use grupos sem captura (?:) quando não precisar capturar
✓ Seja específico (evite .* quando possível)
✓ Use grupos atômicos para prevenir backtracking
✓ Ancore padrões quando possível (^, $, \b)
✓ Teste com entradas grandes
✓ Evite quantificadores aninhados
✓ Use classes de caracteres [abc] ao invés de (a|b|c)

**Armadilhas Comuns:**

❌ Backtracking catastrófico: `(a+)+b`
❌ Muito ganancioso: `.*` casando demais
❌ Âncoras faltando: correspondências parciais
❌ Esquecer de escapar: `. * + ? [ ] ( ) { } ^ $ | \`
❌ Não testar casos extremos

Principais Recursos

• Interface de construtor visual de padrões
• Biblioteca abrangente de padrões
• Padrões regex comuns (email, URL, telefone, etc.)
• Inserção rápida de componentes
• Teste de padrão em tempo real
• Destaque e visualização de correspondências
• Exibição de grupos capturados
• Contagem e posições de correspondências
• Gerador de explicação de padrões
• Decomposição componente por componente
• Suporte a flags de regex (g, i, m, s)
• Geração de código para múltiplas linguagens
• Saída de código JavaScript
• Saída de código Python
• Saída de código PHP
• Saída de código Java
• Saída de código Ruby
• Saída de código Go
• Destaque de sintaxe
• Copiar para área de transferência
• Baixar como arquivo de código
• Nenhum dado enviado para servidor
• Funciona offline
• Interface responsiva para mobile
• Suporte a modo escuro
• 100% gratuito
• Não requer registro