 |
| Bellacosa Mainframe e o regex sem misterios |
☕ Um Café no Bellacosa Mainframe
Regex sem Mistérios — A Linguagem Secreta que Todo Programador COBOL Padawan Precisa Conhecer
Como encontrar, validar, limpar e transformar dados caóticos usando Expressões Regulares — com exemplos, curiosidades, armadilhas e analogias dignas da Frota Estelar
Existe um momento inevitável na carreira de qualquer profissional de tecnologia.
Você recebe um arquivo.
À primeira vista, parece apenas mais um CSV inofensivo vindo de algum sistema legado, planilha departamental, parceiro comercial, API moderna ou aplicação construída às pressas numa sexta-feira à tarde.
Então você abre o arquivo.
E encontra isto:
JOAO DA SILVA
João da Silva
joao da silva
JOAO DA SILVA
Depois aparecem os telefones:
11999999999
(11) 99999-9999
+55 11 99999-9999
11-99999-9999
99999 9999
Logo abaixo, as datas:
17/07/2026
2026-07-17
17-07-26
20260717
Jul 17, 2026
E, como se a tripulação tivesse entrado em uma anomalia temporal, surgem e-mails sem domínio, endereços IP impossíveis, preços com ponto e vírgula trocados, espaços em excesso e descrições misturadas com informações entre parênteses.
Nesse instante, o programador percebe que o problema não é apenas “ler o arquivo”.
O problema é reconhecer padrões dentro do caos.
É aí que entra a Regex.
Regex é a abreviação de Regular Expression, ou Expressão Regular. Trata-se de uma pequena linguagem especializada em localizar, validar, extrair, substituir e reorganizar padrões dentro de textos.
Pode parecer estranha no começo.
Uma Regex típica se parece com isso:
^[\w.-]+@[\w.-]+\.\w{2,}$
Para quem está começando, isso parece uma mensagem interceptada de uma nave romulana.
Mas, quando desmontamos a expressão peça por peça, tudo começa a fazer sentido.
E esse é o objetivo desta missão: mostrar que Regex não é magia negra, não é privilégio de cientistas de dados e tampouco exige decorar centenas de símbolos.
Você precisa aprender a enxergar os componentes.
Assim como um programa COBOL é construído com IDENTIFICATION DIVISION, DATA DIVISION, PROCEDURE DIVISION, campos PIC, condições, PERFORM e IF, uma Regex também é formada por pequenos blocos previsíveis.
Prepare o café, ajuste o uniforme da Frota e abra o terminal.
Nossa missão começa agora.
1. O que é uma Expressão Regular?
Uma Expressão Regular é uma descrição compacta de um padrão textual.
Imagine que você deseja encontrar todas as matrículas formadas por três letras seguidas de quatro números:
ABC1234
XPTO9876
ZOS2026
Você poderia procurar cada matrícula individualmente.
Mas isso seria impossível se existissem milhares delas.
Com Regex, você descreve o formato:
[A-Z]{3}\d{4}
Essa expressão significa:
[A-Z] → uma letra maiúscula
{3} → repetida exatamente três vezes
\d → um dígito
{4} → repetido exatamente quatro vezes
Portanto:
[A-Z]{3}\d{4}
significa:
encontre três letras maiúsculas seguidas de quatro números.
A Regex não precisa saber quais letras ou números aparecerão. Ela sabe apenas qual estrutura deve procurar.
Isso muda completamente a maneira de lidar com textos.
2. Regex é como uma cláusula PIC do COBOL
Para um programador COBOL, existe uma comparação especialmente útil.
Considere:
01 WS-CODIGO PIC X(3)9(4).
Esse campo espera:
Em Regex, um padrão semelhante poderia ser:
^[A-Z]{3}\d{4}$
As duas construções descrevem um formato esperado.
A diferença é que a cláusula PIC define como o dado será armazenado em um campo COBOL, enquanto a Regex procura ou valida padrões em textos.
Podemos imaginar que a Regex é uma espécie de PIC móvel.
Ela percorre uma linha, um arquivo, uma página, um log ou uma coluna inteira procurando ocorrências compatíveis.
Essa analogia é poderosa porque retira a Regex do território do mistério.
Você já conhece a ideia.
Apenas muda a sintaxe.
3. Onde Regex aparece?
Muitos programadores COBOL acreditam que Regex pertence apenas ao mundo de JavaScript ou Python.
Nada poderia estar mais distante da realidade moderna.
Regex aparece em:
No universo IBM Z, talvez você não execute Regex diretamente em um programa COBOL tradicional, mas certamente poderá encontrá-la em scripts auxiliares, automações, pipelines, arquivos YAML, utilitários Linux, integrações REST e processos de modernização.
O mainframe não vive isolado.
Ele conversa com o restante da galáxia.
E Regex é um dos idiomas usados nessas comunicações.
4. Os símbolos fundamentais da Regex
Antes de estudar os quinze padrões essenciais, precisamos conhecer as peças básicas.
O ponto: .
Em Regex, o ponto normalmente representa qualquer caractere.
a.c
Pode encontrar:
abc
a1c
a-c
a_c
O ponto não significa necessariamente um ponto literal.
Para procurar um ponto verdadeiro, usamos:
\.
Esse detalhe é extremamente importante.
A expressão:
\d+.\d+
aceita:
12.50
12,50
12X50
Porque o ponto significa qualquer caractere.
A versão mais correta seria:
\d+\.\d+
Agora, o separador precisa ser realmente um ponto.
O asterisco: *
Representa zero ou mais ocorrências.
AB*
Pode aceitar:
A
AB
ABB
ABBBBB
O B pode não aparecer ou aparecer várias vezes.
O sinal de mais: +
Representa uma ou mais ocorrências.
AB+
Aceita:
AB
ABB
ABBBBB
Mas não aceita apenas:
A
O ponto de interrogação: ?
Indica que o elemento anterior é opcional.
https?
Aceita:
http
https
O s pode existir ou não.
Os colchetes: []
Definem uma classe de caracteres.
[ABC]
Procura:
A
B
C
Já:
[A-Z]
representa qualquer letra maiúscula entre A e Z.
E:
[0-9]
representa qualquer dígito.
\d
Representa um dígito.
\d
É semelhante a:
[0-9]
\w
Normalmente representa letras, números e sublinhado.
\w
Pode encontrar:
A
z
5
_
O comportamento exato pode variar conforme o mecanismo Regex e o suporte a Unicode.
\s
Representa caracteres de espaço em branco.
Pode incluir:
espaço normal;
tabulação;
quebra de linha;
retorno de carro.
Circunflexo: ^
Indica o começo da string ou da linha.
^ABC
Encontra:
ABC123
Mas não encontra:
000ABC123
Cifrão: $
Indica o final da string ou da linha.
XYZ$
Encontra:
123XYZ
Mas não:
XYZ123
Quando usamos:
^\d+$
estamos dizendo:
do começo ao fim, aceite somente dígitos.
Chaves: {}
Controlam quantidades.
\d{4}
Exatamente quatro dígitos.
\d{2,4}
Entre dois e quatro dígitos.
\d{2,}
Dois ou mais dígitos.
Parênteses: ()
Criam grupos.
(ABC)+
Pode encontrar:
ABC
ABCABC
ABCABCABC
Os grupos também podem capturar partes específicas do texto.
Barra vertical: |
Significa “ou”.
COBOL|PL/I|REXX
Encontra qualquer uma das três palavras.
5. Padrão 1 — Endereço de e-mail
Uma expressão prática para e-mails simples é:
^[\w.-]+@[\w.-]+\.[A-Za-z]{2,}$
Vamos desmontar:
^
Começo da string.
[\w.-]+
Uma ou mais letras, números, sublinhados, pontos ou hífens.
@
O caractere arroba obrigatório.
[\w.-]+
O domínio.
\.
Um ponto literal.
[A-Za-z]{2,}
Uma extensão com pelo menos duas letras.
$
Fim da string.
Aceita:
usuario@gmail.com
vagner.bellacosa@empresa.com.br
programador-cobol@mainframe.org
Rejeita:
usuario@
@empresa.com
usuario.com
usuario@empresa
Porém existe uma observação importante.
E-mails reais podem seguir regras muito complexas. O padrão oficial permite formatos que quase nunca vemos no dia a dia.
Portanto, uma Regex simples é excelente para detectar erros comuns, mas não deve ser considerada uma implementação completa de todas as regras possíveis de e-mail.
Uma dica prática: em sistemas reais, muitas vezes o melhor teste de e-mail é enviar uma mensagem de confirmação.
A Regex valida o formato.
O envio confirma a existência operacional.
6. Padrão 2 — Número de telefone
Telefone é um dos maiores desafios de validação.
Considere:
+55 11 99999-9999
(11) 99999-9999
11 99999 9999
11999999999
+1 (555) 123-4567
Não existe uma única Regex perfeita para todos os países.
Uma expressão prática para formatos brasileiros poderia ser:
^(?:\+55\s?)?(?:\(?\d{2}\)?\s?)?\d{4,5}[-\s]?\d{4}$
Ela permite:
código do Brasil opcional;
DDD opcional;
parênteses opcionais;
espaço ou hífen opcional;
telefone com oito ou nove dígitos locais.
Mesmo assim, formato válido não significa número existente.
Uma Regex pode aceitar:
(00) 00000-0000
Embora isso não represente um telefone real utilizável.
Em aplicações internacionais, o ideal é normalizar os dados e trabalhar com um padrão como E.164:
+5511999999999
Esse formato remove espaços, parênteses e hífens, preservando apenas o sinal de mais, o código do país e o número.
7. Padrão 3 — Data no formato DD/MM/AAAA
Uma expressão comum é:
\b(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/\d{4}\b
Ela limita:
dia entre 01 e 31;
mês entre 01 e 12;
ano com quatro dígitos.
Aceita:
17/07/2026
01/01/2000
31/12/1999
Mas pode aceitar:
31/02/2026
Por quê?
Porque Regex reconhece formato, não necessariamente lógica de calendário.
Ela sabe que 31 está dentro de 01 a 31.
Ela sabe que 02 está dentro de 01 a 12.
Mas não sabe automaticamente que fevereiro não possui 31 dias.
Para validar datas reais, o procedimento recomendado é:
usar Regex para verificar o formato;
converter o texto para um tipo de data;
deixar a linguagem ou banco de dados validar o calendário.
É o equivalente a uma primeira inspeção feita pelo sensor da nave, seguida por uma análise completa no computador de bordo.
8. Padrão 4 — Data ISO AAAA-MM-DD
\b\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])\b
Aceita:
2026-07-17
2025-12-31
2000-01-01
O formato ISO é excelente porque organiza as partes da maior para a menor:
ano-mês-dia
Isso traz vantagens para ordenação textual.
Considere:
2024-12-31
2025-01-01
2026-07-17
Mesmo como texto, a ordem cronológica é preservada.
Por isso, esse formato aparece em:
APIs;
bancos de dados;
logs;
arquivos CSV;
integrações;
sistemas distribuídos;
aplicações modernas.
Para um programador COBOL envolvido com APIs e modernização, o formato ISO deve se tornar um velho amigo.
9. Padrão 5 — Horário HH:MM
\b([01][0-9]|2[0-3]):[0-5][0-9]\b
Aceita:
00:00
09:30
18:45
23:59
Rejeita:
24:00
12:99
99:99
A primeira parte:
([01][0-9]|2[0-3])
aceita horas de 00 a 23.
A segunda:
[0-5][0-9]
aceita minutos de 00 a 59.
Essa expressão é muito útil para:
10. Padrão 6 — URL
Uma Regex simples:
https?://[^\s]+
Significa:
http
seguido de um s opcional
seguido de ://
seguido de um ou mais caracteres que não sejam espaços
Aceita:
https://www.ibm.com
http://servidor.local/relatorio
https://exemplo.com/api/clientes?id=10
Essa expressão é útil para extração, mas não valida toda a estrutura de uma URL.
Também pode capturar pontuação colada no final:
Acesse https://exemplo.com.
Dependendo do mecanismo, o ponto final poderá entrar na captura.
Podemos refinar o padrão, mas existe uma lição importante:
quanto mais perfeita tentamos tornar uma Regex, mais complexa e difícil de manter ela pode ficar.
Regex deve resolver o problema necessário, não todos os problemas possíveis do universo.
11. Padrão 7 — Nome de domínio
Uma expressão prática:
\b(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}\b
Pode encontrar:
ibm.com
empresa.com.br
portal.exemplo.org
mainframe.local
Esse tipo de extração aparece em:
Por exemplo, a partir do e-mail:
usuario@empresa.com.br
podemos extrair:
empresa.com.br
E então agrupar contatos por organização.
12. Padrão 8 — Endereço IPv4
Uma expressão estrutural simples:
\b(?:\d{1,3}\.){3}\d{1,3}\b
Ela encontra:
192.168.0.1
10.0.0.25
172.16.1.100
Porém também pode aceitar:
999.999.999.999
Isso acontece porque cada bloco aceita de um a três dígitos, sem verificar o limite de 255.
Uma versão mais rigorosa é:
\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)\b
Essa expressão é mais precisa, mas também muito menos legível.
Aqui surge uma decisão de engenharia:
Para extração inicial de logs, a versão simples pode bastar.
Para segurança ou configuração de rede, a versão rigorosa ou uma biblioteca de IP é mais apropriada.
13. Padrão 9 — Valores monetários
Valores monetários são traiçoeiros porque cada país usa formatos diferentes.
Brasil:
R$ 1.299,99
R$ 25,00
1.000.000,50
Estados Unidos:
$1,299.99
$25.00
1,000,000.50
Uma expressão básica para valores brasileiros:
R\$\s?\d{1,3}(?:\.\d{3})*(?:,\d{2})?
Aceita:
R$ 25
R$ 1.299,99
R$ 10.000.000,50
Uma expressão básica para valores em dólares:
\$\s?\d{1,3}(?:,\d{3})*(?:\.\d{2})?
Nunca assuma o separador decimal sem conhecer a origem do dado.
Um erro de interpretação pode transformar:
1.234
em mil duzentos e trinta e quatro ou em um vírgula duzentos e trinta e quatro, dependendo da convenção utilizada.
Em sistemas financeiros, esse detalhe não é cosmético.
É crítico.
14. Padrão 10 — Percentuais
\b\d+(?:[.,]\d+)?%
Aceita:
18%
42,5%
98.75%
A parte:
(?:[.,]\d+)?
permite uma parte decimal opcional com ponto ou vírgula.
Mas novamente devemos perguntar:
o valor máximo é 100%?
valores acima de 100% são permitidos?
números negativos são válidos?
deve haver espaço antes do sinal de porcentagem?
Em relatórios de crescimento, isto pode ser válido:
250%
Em progresso de uma tarefa, talvez não.
A Regex deve refletir a regra do negócio, não apenas a aparência do dado.
15. Padrão 11 — Somente números
^\d+$
É uma das expressões mais úteis de todas.
Ela verifica se a string inteira possui apenas dígitos.
Aceita:
12345
000001
987654321
Rejeita:
123A
12-34
123
123
Pode ser utilizada para validar:
matrícula;
código de cliente;
CPF sem máscara;
número de lote;
quantidade;
identificador numérico.
Mas cuidado: um campo formado apenas por dígitos não é necessariamente um número matemático.
Um CPF, CEP ou código de cliente pode começar com zero.
Se convertermos:
001234
para número, podemos obter:
1234
e perder informação.
Isso também é familiar ao programador COBOL.
Nem todo PIC 9 representa um valor que deve participar de cálculos. Às vezes ele é apenas um identificador composto por caracteres numéricos.
16. Padrão 12 — Número decimal
^-?\d+(?:\.\d+)?$
Aceita:
10
10.5
-25
-25.75
A parte:
-?
permite um sinal negativo opcional.
A parte:
\d+
exige pelo menos um dígito.
E:
(?:\.\d+)?
permite uma parte decimal opcional.
Para vírgula decimal brasileira:
^-?\d+(?:,\d+)?$
Ou, para aceitar ambos:
^-?\d+(?:[.,]\d+)?$
Entretanto, aceitar os dois formatos pode gerar ambiguidades em dados com separadores de milhar.
A melhor estratégia costuma ser:
identificar o padrão de origem;
remover separadores de milhar;
normalizar o separador decimal;
converter para número.
17. Padrão 13 — Remover espaços extras
\s+
Substitua por um único espaço:
" "
Antes:
Analista de Sistemas
Depois:
Analista de Sistemas
Esse padrão é extremamente poderoso.
Mas ele também pode substituir:
tabs;
quebras de linha;
múltiplos espaços.
Portanto, se você estiver trabalhando com um texto multilinha, pode acabar transformando parágrafos inteiros em uma única linha.
Para espaços horizontais apenas, alguns mecanismos oferecem:
[ \t]+
Isso procura espaços e tabulações, mas não quebras de linha.
Sempre teste a substituição em uma cópia do arquivo.
A primeira diretriz da Frota Estelar de tratamento de dados deveria ser:
nunca execute uma transformação destrutiva sem possuir backup e uma amostra de validação.
18. Padrão 14 — Remover espaços do começo e do final
^\s+|\s+$
Significa:
espaços no começo
OU
espaços no final
Antes:
" Power BI Dashboard "
Depois:
"Power BI Dashboard"
Essa operação é chamada de trim.
Em linguagens modernas, normalmente existe uma função pronta para isso.
Mesmo assim, a Regex é útil quando estamos fazendo substituições em massa dentro de um editor, ferramenta ETL ou arquivo inteiro.
19. Padrão 15 — Texto dentro de parênteses
Para capturar o conteúdo entre parênteses:
\((.*?)\)
Considere:
Plano Corporativo (Premium)
A captura será:
Premium
Os parênteses literais precisam ser escapados:
\(
\)
O trecho:
.*
significa qualquer caractere, zero ou mais vezes.
O ponto de interrogação torna a busca não gulosa:
.*?
Isso significa que a Regex captura o mínimo necessário.
Sem o ?, em:
Produto (Azul) Tamanho (Grande)
uma expressão gulosa poderia capturar:
(Azul) Tamanho (Grande)
Com:
\((.*?)\)
ela pode capturar separadamente:
Azul
Grande
O conceito de busca gulosa é uma das curiosidades mais importantes da Regex.
Um quantificador guloso tenta consumir o máximo possível.
Um quantificador não guloso tenta consumir o mínimo necessário.
20. Regex encontra formato, não verdade
Esta é provavelmente a lição mais importante de todo o artigo.
Uma Regex pode reconhecer que:
usuario@empresa.com
tem aparência de e-mail.
Mas não sabe se a caixa postal existe.
Pode reconhecer:
31/02/2026
como uma data estruturada.
Mas não sabe se o dia existe no calendário.
Pode reconhecer:
999.999.999.999
como algo semelhante a IPv4, dependendo da expressão.
Mas não sabe automaticamente que os octetos são inválidos.
Pode reconhecer:
R$ 999999999999
como valor monetário.
Mas não sabe se o valor faz sentido para aquela transação.
Regex trabalha na camada sintática.
A lógica de negócio trabalha na camada semântica.
Em linguagem de Frota Estelar:
Regex é o scanner. A aplicação é o oficial científico que interpreta o resultado.
21. Passo a passo para construir uma Regex
Não comece tentando escrever a expressão inteira.
Siga um processo.
Passo 1 — Reúna exemplos válidos
Imagine códigos:
CLI-0001
CLI-1025
CLI-9999
Passo 2 — Reúna exemplos inválidos
CLI0001
cli-0001
CLI-001
CLI-12345
Passo 3 — Identifique partes fixas
CLI-
Passo 4 — Identifique partes variáveis
Quatro dígitos:
\d{4}
Passo 5 — Monte o padrão
CLI-\d{4}
Passo 6 — Ancore o começo e o final
^CLI-\d{4}$
Passo 7 — Teste casos extremos
CLI-0000
CLI-9999
CLI-12A4
XCLI-0001
CLI-0001-TESTE
Passo 8 — Documente
Explique o que a Regex faz.
Não deixe apenas:
^(?:\+55\s?)?(?:\(?\d{2}\)?\s?)?\d{4,5}[-\s]?\d{4}$
Adicione um comentário no código ou documentação.
Uma Regex não documentada pode se tornar um artefato klingon perdido dentro do sistema.
Todos têm medo de alterá-la.
Ninguém sabe exatamente o que ela faz.
22. Regex em Python — pequeno laboratório
import re
dados = [
"usuario@gmail.com",
"email-invalido",
"programador@empresa.com.br"
]
padrao = re.compile(r"^[\w.-]+@[\w.-]+\.[A-Za-z]{2,}$")
for valor in dados:
if padrao.fullmatch(valor):
print(f"Válido: {valor}")
else:
print(f"Inválido: {valor}")
Resultado esperado:
Válido: usuario@gmail.com
Inválido: email-invalido
Válido: programador@empresa.com.br
Observe o prefixo r antes da string:
r"..."
Em Python, isso cria uma raw string, reduzindo conflitos entre as barras invertidas da linguagem e as barras utilizadas pela Regex.
23. Regex no PowerShell
No Windows, um Padawan pode experimentar:
$email = "usuario@empresa.com"
if ($email -match '^[\w.-]+@[\w.-]+\.[A-Za-z]{2,}$') {
Write-Host "E-mail válido"
} else {
Write-Host "E-mail inválido"
}
Para substituir espaços repetidos:
$texto = "Programador COBOL Padawan"
$limpo = $texto -replace '\s+', ' '
Write-Host $limpo
Resultado:
Programador COBOL Padawan
24. Regex no Linux e no USS
Com grep:
grep -E '^[0-9]+$' arquivo.txt
Isso procura linhas compostas apenas por números.
Para encontrar datas ISO:
grep -E '\b[0-9]{4}-[0-9]{2}-[0-9]{2}\b' aplicacao.log
Com sed, podemos reduzir espaços:
sed -E 's/[[:space:]]+/ /g' arquivo.txt
No Unix System Services do z/OS, esses recursos podem fazer parte de scripts de automação, preparação de dados, análise de logs e pipelines DevOps.
25. Armadilhas comuns
Esquecer de escapar o ponto
Errado:
\d+.\d+
Melhor:
\d+\.\d+
Usar Regex para tudo
Regex não é a melhor ferramenta para interpretar estruturas profundamente aninhadas.
Tentar processar JSON ou XML complexo inteiramente com Regex costuma produzir soluções frágeis.
Para JSON, use um parser JSON.
Para XML, use um parser XML.
Use Regex para tarefas localizadas, como identificar padrões simples antes ou depois do parsing.
Criar uma expressão impossível de manter
Uma Regex gigantesca pode funcionar, mas tornar a manutenção perigosa.
Às vezes é melhor dividir a validação em etapas:
normalizar;
verificar formato;
converter;
aplicar regra de negócio.
Não considerar Unicode e acentos
Padrões como:
[A-Za-z]
não incluem automaticamente:
á
é
ç
õ
ü
Dependendo da linguagem, você pode usar recursos Unicode, propriedades como \p{L} ou flags específicas.
Não testar casos negativos
Muitas pessoas testam apenas entradas válidas.
Uma boa bateria de testes deve conter:
entradas válidas;
entradas inválidas;
valores vazios;
espaços;
caracteres especiais;
limites máximos;
limites mínimos;
texto muito longo;
acentos;
valores nulos.
26. Dicas de sobrevivência para o Padawan
Primeira dica: não memorize Regex inteiras.
Memorize conceitos:
^ começo
$ final
\d dígito
\w caractere de palavra
\s espaço
+ uma ou mais vezes
* zero ou mais vezes
? opcional
[] classe
() grupo
| ou
{} quantidade
Segunda dica: construa aos poucos.
Terceira dica: teste em uma amostra pequena.
Quarta dica: mantenha exemplos válidos e inválidos.
Quinta dica: dê nome ao padrão no código.
Em vez de:
if re.match(r"^[\w.-]+@[\w.-]+\.[A-Za-z]{2,}$", texto):
prefira:
PADRAO_EMAIL_SIMPLES = r"^[\w.-]+@[\w.-]+\.[A-Za-z]{2,}$"
if re.match(PADRAO_EMAIL_SIMPLES, texto):
Sexta dica: documente limitações.
Exemplo:
Valida apenas o formato geral do e-mail.
Não implementa integralmente todas as regras da RFC.
Sétima dica: não confie em Regex como única barreira de segurança.
Regex pode ajudar a validar entrada, mas segurança exige escaping, parametrização, autorização, limites de tamanho e tratamento adequado de dados.
27. Easter egg da Frota Estelar
Imagine que o computador da USS Enterprise recebeu o seguinte log:
STARDATE=47634.44 | SHIP=NCC-1701-D | STATUS=WARP_CORE_WARNING
STARDATE=47634.45 | SHIP=NCC-1701-D | STATUS=STABLE
STARDATE=47634.46 | SHIP=NCC-74656 | STATUS=TRANSWARP_DETECTED
Queremos extrair apenas os registros da Enterprise-D:
SHIP=NCC-1701-D
Queremos extrair todas as naves:
SHIP=NCC-\d+(?:-[A-Z])?
Isso poderia encontrar:
SHIP=NCC-1701-D
SHIP=NCC-74656
Queremos extrair todas as datas estelares:
STARDATE=\d+\.\d+
E agora o Easter egg:
procure no log uma nave cujo registro contenha:
NCC-1701
Ao encontrar esse padrão, o sistema poderia responder:
Tea, Earl Grey, hot.
Sim, Padawan: até uma Regex pode conter espírito de tripulação.
28. Curiosidades sobre Regex
Expressões regulares possuem raízes na matemática e na ciência da computação teórica.
O conceito está relacionado a linguagens formais e autômatos finitos.
Posteriormente, Regex tornou-se popular em ferramentas de processamento de texto, especialmente no ambiente Unix e em linguagens como Perl.
Perl teve enorme influência na sintaxe moderna das expressões regulares.
Por isso, muitos mecanismos são chamados de “compatíveis com Perl” ou PCRE, de Perl Compatible Regular Expressions.
Mas nem toda implementação é idêntica.
Uma expressão que funciona em Python pode precisar de ajustes em:
Java;
JavaScript;
PowerShell;
grep;
sed;
banco de dados;
editor de texto.
Alguns mecanismos suportam:
Outros possuem limitações.
Sempre confirme qual mecanismo Regex está sendo utilizado.
29. Regex e qualidade de dados
Regex não serve apenas para encontrar texto.
Ela participa diretamente da qualidade dos dados.
Podemos usar Regex para:
detectar campos fora do padrão;
separar registros válidos e inválidos;
normalizar entradas;
extrair partes relevantes;
mascarar informações;
remover ruído;
identificar anomalias;
construir regras de qualidade;
preparar dados para análise.
Imagine uma coluna com CPFs:
123.456.789-00
12345678900
123 456 789 00
CPF: 123.456.789-00
Primeiro, poderíamos remover tudo que não seja dígito:
\D
Substituindo por vazio.
Resultado:
12345678900
12345678900
12345678900
12345678900
Depois, validamos se existem onze dígitos:
^\d{11}$
Isso ainda não valida os dígitos verificadores do CPF.
Essa validação exige algoritmo específico.
Mais uma vez:
30. Um plano de aprendizado em sete missões
Missão 1 — Aprender os metacaracteres
Pratique:
.
*
+
?
^
$
[]
()
{}
|
Missão 2 — Aprender as classes
\d
\w
\s
\D
\W
\S
Missão 3 — Validar campos simples
Crie expressões para:
matrícula;
CEP;
data;
horário;
código de produto.
Missão 4 — Extrair informações
Use Regex para extrair:
e-mails;
URLs;
IPs;
números;
textos entre parênteses.
Missão 5 — Fazer substituições
Experimente:
reduzir espaços;
remover caracteres;
reorganizar datas;
limpar máscaras.
Missão 6 — Integrar com uma linguagem
Escolha:
Missão 7 — Aplicar em um problema real
Pegue uma cópia de um arquivo bagunçado e execute um pequeno processo:
entrada
→ identificação
→ normalização
→ validação
→ rejeição
→ saída limpa
Esse fluxo transforma conhecimento em habilidade.
Conclusão — Regex não é magia; é reconhecimento de padrões
Quando olhamos pela primeira vez para:
^(?:\+55\s?)?(?:\(?\d{2}\)?\s?)?\d{4,5}[-\s]?\d{4}$
é natural sentir que estamos diante de uma linguagem extraterrestre.
Mas não estamos.
A expressão é formada por pequenas decisões:
começo da linha;
código do país opcional;
espaço opcional;
DDD opcional;
parênteses opcionais;
quatro ou cinco dígitos;
separador opcional;
quatro dígitos finais;
fim da linha.
Cada símbolo possui função.
Cada grupo representa uma regra.
A Regex só parece complicada quando tentamos enxergá-la inteira de uma vez.
O segredo é desmontá-la.
É exatamente como analisar um programa COBOL antigo com vinte mil linhas.
Você não compreende tudo olhando o fonte inteiro.
Você identifica:
arquivos;
layouts;
campos;
parágrafos;
chamadas;
condições;
regras;
pontos de entrada;
saídas.
Regex segue o mesmo princípio.
Divida.
Nomeie.
Teste.
Documente.
Evolua.
Não tente decorar todas as expressões possíveis. Nem Spock faria isso.
Aprenda os componentes fundamentais e mantenha um pequeno arsenal de padrões úteis.
O verdadeiro poder não está em possuir uma lista com quinze Regex.
Está em compreender como adaptá-las.
Quando chegar o arquivo com quarenta mil telefones inconsistentes, datas em cinco formatos e clientes cadastrados por sistemas de épocas diferentes, você não verá mais caos.
Você verá padrões.
E quando o restante da equipe perguntar como você conseguiu limpar o arquivo em minutos, ajuste o comunicador, olhe para a tela verde do terminal e responda com serenidade:
“Não foi magia. Foi lógica aplicada ao texto.”
Missão cumprida, tripulante.
O arquivo está limpo.
Os dados foram validados.
A Enterprise pode voltar à velocidade de dobra.
