Testador de Regex

Teste expressões regulares em um texto e veja todas as correspondências destacadas

Experimente um exemplo

Padrão

//g

Texto de teste

Roda localmente · Seguro para colar segredos

O que é uma expressão regular?

Uma expressão regular (regex ou regexp) é uma sequência de caracteres que define um padrão de busca. Testadores de regex permitem escrever um padrão, executá-lo em um texto de amostra e ver todas as correspondências destacadas em tempo real. O conceito remonta ao trabalho do matemático Stephen Kleene sobre linguagens regulares nos anos 1950, e Ken Thompson incorporou o primeiro motor de regex ao editor de texto QED em 1968.

Um motor de regex lê um padrão da esquerda para a direita, consumindo caracteres da entrada enquanto tenta encontrar correspondências. Ele usa backtracking quando uma correspondência parcial falha: o motor recua e tenta caminhos alternativos pelo padrão. Alguns motores (como o RE2 usado no Go) evitam o backtracking inteiramente convertendo padrões em autômatos finitos determinísticos (DFA), o que garante correspondência em tempo linear ao custo de não suportar recursos como referências retroativas.

A sintaxe de regex é padronizada de forma aproximada. O PCRE (Perl Compatible Regular Expressions) é o dialeto mais comum, suportado por PHP, pelo módulo re do Python e pelo JavaScript com pequenas diferenças. O POSIX define uma sintaxe mais limitada usada pelo grep e pelo sed. As diferenças importam ao portar padrões entre linguagens: um lookahead que funciona em JavaScript pode não compilar no motor RE2 do Go.

Por que usar um testador de regex online?

Escrever regex em um arquivo de código exige salvar, executar e inspecionar a saída a cada ajuste no padrão. Um testador de regex no navegador elimina completamente esse ciclo: você digita e vê as correspondências.

Destaque de correspondências em tempo real
Cada tecla digitada atualiza os resultados instantaneamente. Você vê quais partes do texto correspondem, quais grupos de captura estão preenchidos e exatamente onde cada correspondência começa e termina. Sem ciclos de compilar-executar-depurar.
🔒
Processamento com privacidade em primeiro lugar
A correspondência de padrões é executada no seu navegador usando o motor JavaScript RegExp. Nenhum texto ou padrão é enviado a um servidor. Isso importa ao testar com arquivos de log, dados de clientes ou respostas de API que contêm informações sensíveis.
🔍
Inspeção visual das correspondências
As correspondências são destacadas inline com suas posições e os valores dos grupos de captura exibidos. Ver as correspondências visualmente facilita identificar erros de deslocamento em quantificadores ou âncoras ausentes.
🌐
Sem cadastro ou instalação
Funciona em qualquer dispositivo com um navegador moderno. Sem criação de conta, sem extensão, sem plugin de IDE. Abra a página, cole seu padrão e texto e comece a testar.

Casos de uso do testador de regex

Validação de entrada no Frontend
Crie e verifique padrões para campos de e-mail, telefone ou cartão de crédito antes de incorporá-los em atributos HTML5 pattern ou em lógica de validação JavaScript.
Análise de logs no Backend
Escreva padrões regex que extraiam timestamps, códigos de erro ou endereços IP de logs de aplicação. Teste com amostras reais de log para confirmar que o padrão captura os grupos corretos.
DevOps e Infraestrutura
Depure regex usados em blocos de localização do Nginx, regras de reescrita do Apache ou regras de alerta do Prometheus. Um padrão errado em uma configuração de servidor pode quebrar o roteamento ou ignorar alertas inteiramente.
QA e Automação de Testes
Valide se corpos de resposta ou saída HTML correspondem aos padrões esperados em asserções de testes de ponta a ponta. Teste o regex aqui antes de adicioná-lo à sua suíte de testes.
Pipelines de Extração de Dados
Prototipe padrões para extrair campos estruturados de texto não estruturado: raspagem de preços de produtos, tratamento de casos extremos em CSV ou extração de metadados de cabeçalhos de e-mail.
Aprendizado de Expressões Regulares
Experimente metacaracteres, quantificadores e grupos com textos de amostra. O feedback visual imediato torna a sintaxe de regex mais fácil de aprender do que apenas ler documentação.

Referência rápida de sintaxe regex

A tabela abaixo cobre os tokens de regex mais usados. Eles funcionam em JavaScript, Python, Go, PHP e na maioria dos motores compatíveis com PCRE. Extensões específicas de cada linguagem (como os padrões condicionais do Python ou os grupos nomeados do JavaScript com sintaxe \k) são indicadas na seção de exemplos de código.

PadrãoNomeDescrição
.Any characterMatches any single character except newline (unless s flag is set)
\dDigitMatches [0-9]
\wWord characterMatches [a-zA-Z0-9_]
\sWhitespaceMatches space, tab, newline, carriage return, form feed
\bWord boundaryMatches the position between a word character and a non-word character
^Start of string/lineMatches the start of the input; with m flag, matches start of each line
$End of string/lineMatches the end of the input; with m flag, matches end of each line
*Zero or moreMatches the preceding token 0 or more times (greedy)
+One or moreMatches the preceding token 1 or more times (greedy)
?OptionalMatches the preceding token 0 or 1 time
{n,m}Quantifier rangeMatches the preceding token between n and m times
()Capturing groupGroups tokens and captures the matched text for back-references
(?:)Non-capturing groupGroups tokens without capturing the matched text
(?=)Positive lookaheadMatches a position followed by the given pattern, without consuming it
(?<=)Positive lookbehindMatches a position preceded by the given pattern, without consuming it
[abc]Character classMatches any one of the characters inside the brackets
[^abc]Negated classMatches any character not inside the brackets
|AlternationMatches the expression before or after the pipe

Flags de regex explicadas

Flags (também chamadas de modificadores) alteram como o motor processa o padrão. Em JavaScript você as adiciona após a barra de fechamento: /padrão/gi. Em Python você as passa como segundo argumento: re.findall(padrão, texto, re.IGNORECASE | re.MULTILINE). Nem todas as flags estão disponíveis em todas as linguagens.

FlagNomeComportamento
gGlobalFind all matches, not just the first one
iCase-insensitiveLetters match both uppercase and lowercase
mMultiline^ and $ match start/end of each line, not just the whole string
sDot-all. matches newline characters as well
uUnicodeTreat the pattern and subject as a Unicode string; enables \u{FFFF} syntax
yStickyMatches only from the lastIndex position in the target string

Exemplos de código

Exemplos funcionais de regex em JavaScript, Python, Go e na linha de comando. Cada exemplo mostra a construção do padrão, a extração de correspondências e a saída.

JavaScript
// Match all email addresses in a string
const text = 'Contact us at support@example.com or sales@example.com'
const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

const matches = text.matchAll(emailRegex)
for (const match of matches) {
  console.log(match[0], 'at index', match.index)
}
// → "support@example.com" at index 14
// → "sales@example.com" at index 37

// Named capture groups (ES2018+)
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const result = '2026-03-30'.match(dateRegex)
console.log(result.groups)
// → { year: "2026", month: "03", day: "30" }

// Replace with a callback
'hello world'.replace(/\b\w/g, c => c.toUpperCase())
// → "Hello World"
Python
import re

# Find all IPv4 addresses
text = 'Server 192.168.1.1 responded, fallback to 10.0.0.255'
pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'

matches = re.findall(pattern, text)
print(matches)  # → ['192.168.1.1', '10.0.0.255']

# Named groups and match objects
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, 'Released on 2026-03-30')
if m:
    print(m.group('year'))   # → '2026'
    print(m.group('month'))  # → '03'

# Compile for repeated use (faster in loops)
compiled = re.compile(r'\b[A-Z][a-z]+\b')
words = compiled.findall('Hello World Foo bar')
print(words)  # → ['Hello', 'World', 'Foo']
Go
package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Find all matches
	re := regexp.MustCompile(`\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b`)
	text := "Contact support@example.com or sales@example.com"
	matches := re.FindAllString(text, -1)
	fmt.Println(matches)
	// → [support@example.com sales@example.com]

	// Named capture groups
	dateRe := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
	match := dateRe.FindStringSubmatch("2026-03-30")
	for i, name := range dateRe.SubexpNames() {
		if name != "" {
			fmt.Printf("%s: %s\n", name, match[i])
		}
	}
	// → year: 2026
	// → month: 03
	// → day: 30

	// Replace with a function
	result := re.ReplaceAllStringFunc(text, func(s string) string {
		return "[REDACTED]"
	})
	fmt.Println(result)
	// → Contact [REDACTED] or [REDACTED]
}
CLI (grep / sed)
# Find lines matching an IP address pattern
grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log

# Extract email addresses from a file
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' contacts.txt

# Replace dates from YYYY-MM-DD to DD/MM/YYYY using sed
echo "2026-03-30" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
# → 30/03/2026

# Count matches per file in a directory
grep -rcE 'TODO|FIXME|HACK' src/
# → src/main.js:3
# → src/utils.js:1

Perguntas Frequentes

Qual é a diferença entre regex e padrões glob?
Padrões glob (como *.txt ou src/**/*.js) são uma sintaxe de curinga simplificada usada para correspondência de caminhos de arquivo em shells e ferramentas de build. Eles suportam * (qualquer caractere), ? (um caractere) e [] (classes de caracteres), mas não têm quantificadores, grupos, lookaheads ou alternância. Regex é muito mais expressivo e opera sobre texto arbitrário, não apenas caminhos de arquivo. O padrão glob *.json é aproximadamente equivalente ao regex ^.*\.json$.
Como faço para corresponder a um ponto literal ou colchete em regex?
Prefixe o caractere com uma barra invertida: \. corresponde a um ponto literal, \[ corresponde a um colchete literal. Dentro de uma classe de caracteres [], um ponto já é literal e não precisa de escape. Um erro comum é escrever 192.168.1.1 sem escapar os pontos, o que também corresponde a 192x168y1z1 porque . significa "qualquer caractere".
Meus dados de teste são enviados a um servidor?
Não. Esta ferramenta executa a correspondência de regex inteiramente no seu navegador usando o motor JavaScript RegExp. Nenhuma requisição de rede é feita com seu texto ou padrão. Você pode confirmar isso abrindo a aba Rede do DevTools do seu navegador enquanto usa a ferramenta.
Por que meu regex funciona em JavaScript mas falha em Python?
JavaScript e Python usam motores de regex diferentes com conjuntos de recursos ligeiramente diferentes. JavaScript suporta \d, lookaheads (?=) e lookbehinds (?<=) desde o ES2018, mas não suporta padrões condicionais, grupos atômicos ou quantificadores possessivos. O módulo re do Python não suporta classes de propriedade Unicode \p{} (use o módulo regex de terceiros). Sempre teste no motor da linguagem de destino ou consulte a documentação de regex da linguagem.
O que causa backtracking catastrófico em regex?
O backtracking catastrófico acontece quando um padrão tem quantificadores aninhados que criam um número exponencial de caminhos de correspondência. O exemplo clássico é (a+)+ aplicado a uma sequência de a's seguida de um caractere que não corresponde. O motor tenta todas as formas possíveis de dividir os a's entre os grupos interno e externo antes de falhar. Para corrigir isso, use grupos atômicos (?>), quantificadores possessivos a++ ou reescreva o padrão para evitar repetição ambígua.
Posso usar regex para analisar HTML?
Regex pode extrair valores simples de fragmentos HTML, como obter o href de uma única tag <a>. Para análise completa de HTML, use um parser adequado (DOMParser em JavaScript, BeautifulSoup em Python ou html/template em Go). HTML é uma gramática livre de contexto, e regex lida com gramáticas regulares. Tags aninhadas, atributos opcionais e elementos de fechamento automático criam padrões que regex não consegue corresponder de forma confiável.
Qual é a diferença entre quantificadores greedy e lazy?
Um quantificador greedy (* ou +) corresponde ao máximo de caracteres possível, recuando se o restante do padrão falhar. Um quantificador lazy (*? ou +?) corresponde ao mínimo de caracteres possível, expandindo apenas quando necessário. Para a entrada <b>um</b><b>dois</b>, o padrão greedy <b>.*</b> corresponde à string inteira desde o primeiro <b> até o último </b>, enquanto o padrão lazy <b>.*?</b> corresponde a <b>um</b> e <b>dois</b> separadamente.