Resumo de Regex e AWK

Guia de Expressões Regulares (Regex)

Uma Expressão Regular é uma microlinguagem de programação embutida em
outras linguagens e ferramentas, usada para definir padrões de busca em textos.
Dominá-la é uma habilidade fundamental para manipulação de dados, automação,
validação de formulários e análise de logs.

Estrutura da Análise:
1. Os Átomos: As unidades mais básicas de uma expressão.
2. Classes de Caracteres: Como definir conjuntos de átomos.
3. Âncoras: Como fixar o padrão a posições específicas no texto.
4. Quantificadores: Como definir a repetição dos átomos.
5. Grupos e Alternância: Como tratar múltiplos átomos como uma unidade
e criar lógicas “OU”.
6. Referências e Captura: Como reutilizar partes do padrão.
7. Lookarounds (Asserções): A técnica avançada para verificar o contexto
sem consumi-lo.
8. Flags (Modificadores): Como alterar o comportamento global do motor
Regex.
9. Exemplo Prático Desconstruído: Análise de uma regex do mundo real.

1. Os Átomos: Caracteres Literais e Metacaracteres

Tudo em Regex é ou um caractere literal ou um metacaractere.
• Caracteres Literais: Correspondem a si mesmos. A regex abc encontrará
exatamente a string “abc”.
• Metacaracteres: Símbolos com significado especial. Os principais são: .
\ * + ? ˆ $ [ ] ( ) { } |.

Símbolo Nome Explicação Detalhada

. Ponto (Curinga) Corresponde a qualquer
caractere único, exceto
quebras de linha (\n).
É um dos
metacaracteres mais
poderosos e perigosos,
pois pode ser vago
demais.

1
Símbolo Nome Explicação Detalhada
\ Escape (Barra Invertida) Torna um metacaractere
em um literal. Se você
quer encontrar um ponto
final real, use \.. Se
quer encontrar uma
barra invertida real, use
\\. Também é usado
para invocar atalhos de
classes (ex: \d).

2. Classes de Caracteres (Conjuntos)

Permitem definir um grupo de caracteres possíveis para uma única posição.

Explicação
Sintaxe Nome Detalhada Exemplo
[abc] Conjunto Corresponde a gr[ae]y
um único corresponde a
caractere que “gray” e “grey”.
seja a, b, ou c.
[ˆabc] Conjunto Negado Corresponde a [ˆ0-9]
um único corresponde a
caractere que qualquer
não seja a, b, ou caractere que não
c. seja um dígito
numérico.
[a-z] Intervalo (Range) Corresponde a [a-zA-Z0-9]
qualquer corresponde a
caractere no qualquer letra ou
intervalo Unicode. dígito.
Útil para
alfabetos e
números.

Atalhos de Classes (Character Escapes) São atalhos convenientes para

conjuntos comuns.

Atalho Equivalente Descrição

\d [0-9] Qualquer dígito.

2
Atalho Equivalente Descrição
\D [ˆ0-9] Qualquer caractere que
não é um dígito.
\w [a-zA-Z0-9_] Qualquer caractere de
“palavra” (alfanumérico
+ underscore).
\W [ˆa-zA-Z0-9_] Qualquer caractere que
não é de palavra
(símbolos, espaços, etc.).
\s [ \t\r\n\f\v] Qualquer caractere de
espaço em branco
(espaço, tab, nova linha,
etc.).
\S [ˆ \t\r\n\f\v] Qualquer caractere que
não é espaço em branco.

3. Âncoras
Não correspondem a caracteres, mas a posições no texto. São “asserções de
largura zero”.

Âncora Nome Explicação Detalhada

ˆ Circunflexo Corresponde ao início da
string. Em modo
multiline (m),
corresponde ao início de
cada linha.
$ Cifrão Corresponde ao fim da
string. Em modo
multiline (m),
corresponde ao fim de
cada linha.
\b Borda de Palavra Corresponde à posição
entre um caractere de
palavra (\w) e um
não-palavra (\W), ou o
início/fim da string.
Essencial para encontrar
palavras inteiras.
\bcat\b encontra “cat”
em “the cat sat”, mas
não em “concatenate”.

3
Âncora Nome Explicação Detalhada
\B Não-Borda O oposto de \b.
Corresponde a qualquer
posição que não seja
uma borda de palavra.

4. Quantificadores
Definem a frequência com que o elemento anterior (caractere, classe ou grupo)
deve ocorrer.

Comportamento
Padrão (Guloso - Comportamento
Quantificador Descrição Greedy) Preguiçoso (Lazy)
* Zero ou mais a.*b em a.*?b em
vezes. “acccbcccb” “acccbcccb”
corresponde a corresponde a
“acccbcccb”. “acccb”.
+ Uma ou mais Tenta casar o Tenta casar o
vezes. máximo possível. mínimo possível.
? Zero ou uma — —
vez (opcional).
{n} Exatamente n — —
vezes.
{n,} n ou mais vezes. Tenta casar o Adicione ? (ex:
máximo possível. {n,}?) para
casar o mínimo.
{n,m} De n a m vezes. Tenta casar o Adicione ? (ex:
máximo possível {n,m}?) para
(m). casar o mínimo
(n).

Gulosos (Greedy) vs. Preguiçoso (Lazy): Por padrão, um quantificador é

“guloso”, ele tentará corresponder à maior sequência de texto possível. Adicio-
nando um ? após o quantificador (*?, +?, {n,m}?), ele se torna “preguiçoso”,
correspondendo à menor sequência possível que ainda satisfaça o padrão geral.

5. Grupos e Alternância

4
Sintaxe Nome Explicação Detalhada
( ) Grupo de Captura 1. Agrupa elementos
para que um
quantificador se aplique
a todos. Ex: (ab)+
corresponde a “ab”,
“abab”, etc. 2. Captura
o texto correspondente
para uso posterior.
(?: ) Grupo de Não-Captura Agrupa elementos como
( ), mas não armazena
o resultado. É mais
eficiente quando você só
precisa agrupar mas não
se importa com a
captura.
\| Alternância (OU) Funciona como um “OU”
lógico, tentando
corresponder à expressão
à esquerda e, se falhar, à
da direita. gato|cão
corresponde a “gato” ou
“cão”. Use grupos para
limitar seu escopo:
(bom|mau) cão.

6. Referências e Captura
Quando um grupo ( ) captura um texto, ele é armazenado em memória, numer-
ado pela ordem do parêntese de abertura.
• Retrorreferência (Backreference): \1, \2, etc., referem-se ao texto
capturado pelo grupo 1, 2, etc., dentro da mesma expressão regular.
– Exemplo: (\w+)\s+\1 encontra palavras repetidas (ex: “hello
hello”). \1 corresponde exatamente ao que (\w+) capturou.
• Uso em Substituição: Em ferramentas de substituição (como sed ou
funções de linguagens), você pode usar $1, $2 (ou \1, \2 dependendo da
implementação) para inserir o texto capturado na string de substituição.

5
7. Lookarounds (Asserções de Vizinhança)
Esta é a ferramenta mais poderosa e complexa. São como âncoras, mas para
padrões dinâmicos. Eles verificam se um padrão existe antes ou depois da
posição atual, mas não incluem esse padrão na correspondência final.
São “asserções de largura zero”.

Explicação
Sintaxe Nome Detalhada Exemplo
(?=...) Lookahead A R(?=\$)
Positivo correspondência corresponde ao
só ocorre se a “R” somente se
posição atual for ele for seguido
seguida pelo por um
padrão dentro de “”.Em”R”, a
.... correspondência é
apenas “R”.
(?!...) Lookahead A \d+(?!\.)
Negativo correspondência corresponde a
só ocorre se a números inteiros,
posição atual mas não a
NÃO for números que são
seguida pelo parte de um
padrão dentro de decimal (ex: em
.... “123.45”,
corresponde a
“12”).
(?<=...) Lookbehind A (?<=R\$)\d+
Positivo correspondência corresponde a um
só ocorre se a número somente
posição atual for se for precedido
precedida pelo por “R$”. Em
padrão dentro de “R$123”, a
.... correspondência é
“123”.
(?<!...) Lookbehind A (?<!-)\d+
Negativo correspondência corresponde a
só ocorre se a números que não
posição atual são negativos.
NÃO for
precedida pelo
padrão dentro de
....

6
8. Flags (Modificadores)
Modificam o comportamento geral do motor Regex.

Flag Nome Descrição

i Case-Insensitive Ignora diferenças entre
maiúsculas e minúsculas
(a e A são tratados como
iguais).
g Global Encontra todas as
correspondências na
string, em vez de parar
na primeira.
m Multiline Permite que ˆ e $
correspondam ao início e
fim de cada linha, não
apenas da string inteira.
s DotAll Permite que o curinga .
corresponda também a
caracteres de quebra de
linha (\n).

9. Exemplo Prático Desconstruído: Validação de E-mail (Simplificada)

Vamos analisar a regex: ˆ[\w\.\-]+@([\w-]+\.)+[\w-]{2,4}$
• ˆ
– Âncora: Início da string. Garante que não haja caracteres antes do
e-mail.
• [\w\.\-]+
– Classe: \w (letras, números, _), \. (ponto literal), - (hífen literal).
– Quantificador: + (uma ou mais vezes).
– Tradução: Corresponde ao nome do usuário, permitindo caracteres
alfanuméricos, pontos e hifens.
• @
– Literal: O caractere “@” literal.
• ([\w-]+\.)+
– Grupo de Captura (1): Agrupa o padrão de domínio/subdomínio.
– [\w-]+: O nome do domínio (letras, números, _, -).
– \.: Um ponto literal.
– Quantificador (externo): + (uma ou mais vezes). Isso permite
subdomínios, como [Link]..
• [\w-]{2,4}
– Classe: O domínio de topo (TLD), como “com”, “net”, “br”.

7
 – Quantificador: {2,4} (de 2 a 4 caracteres).
• $
– Âncora: Fim da string. Garante que não haja caracteres depois do
e-mail.

O Manual da Linguagem AWK

AWK é muito mais do que um comando; é uma linguagem de programação
interpretada, orientada a dados, cuja genialidade reside em seu modelo de
processamento. Pense nela como uma planilha programável para o seu
terminal, que opera sobre fluxos de texto.

1. O Paradigma do AWK: O Coração do Processamento

Para entender AWK, é preciso entender seu loop de processamento implícito.
Diferente de outras linguagens onde você precisa abrir um arquivo e iterar sobre
ele, o AWK encapsula essa lógica.
O Ciclo de Vida de uma Execução AWK:
1. (Fase de Inicialização): O AWK executa o código dentro do bloco
BEGIN. Isso acontece uma única vez, antes de qualquer linha do arquivo
de entrada ser lida. É o local perfeito para inicializar variáveis, definir
separadores de campo e imprimir cabeçalhos.
2. (Fase de Processamento): O AWK lê a entrada (arquivo ou stdin)
registro por registro (por padrão, um registro é uma linha). Para cada
registro lido, ele executa o seguinte sub-ciclo:
a. O registro é dividido em campos com base no separador de campos
(FS).
b. O AWK testa o registro contra cada par padrão { ação } presente
no script, na ordem em que foram escritos.
c. Se um padrão for satisfeito (resultar em “verdadeiro”), a ação corre-
spondente é executada.
d. Este sub-ciclo se repete para todos os pares padrão { ação }.
e. O AWK descarta o registro atual e volta ao início da Fase de Proces-
samento para ler o próximo.
3. (Fase de Finalização): Após o último registro da entrada ter sido
processado, o AWK executa o código dentro do bloco END. Isso também
acontece uma única vez. É o local ideal para realizar cálculos finais,
imprimir totais, médias e relatórios sumarizados.

2. A Sintaxe Desconstruída: padrão { ação }

Esta é a unidade fundamental de um programa AWK.

8
a. Ações: O que fazer {...} O bloco de ação é um conjunto de instruções,
similar à sintaxe da linguagem C.
• Impressão:
– print: O comando mais fundamental.
∗ { print } ou { print $0 }: Imprime o registro inteiro atual.
∗ { print $1, $NF }: Imprime o primeiro e o último campo. A
vírgula insere o Separador de Campo de Saída (OFS).
∗ { print $1 $NF }: Imprime o primeiro e o último campo con-
catenados, sem separador.
– printf: Para impressão formatada precisa, herdada do C.
∗ { printf "| %-20s | %10.2f |\n", $2, $4 * $3 }
∗ %-20s: String (s), alinhada à esquerda (-), com 20 caracteres de
largura.
∗ %10.2f: Ponto flutuante (f), com 10 caracteres de largura total
e 2 casas decimais.
∗ \n: Nova linha.
• Expressões e Aritmética:
– AWK suporta todas as operações aritméticas padrão (+, -, *, /, %, ˆ).
– { total_vendas += $3 * $4 }
• Estruturas de Controle:
– if (condição) { ... } else { ... }
– while (condição) { ... }
– for (inicialização; condição; incremento) { ... }
– for (variável in array) { ... } (para iterar em arrays associa-
tivos).

b. Padrões: Quando fazer O padrão é uma expressão que resulta em

verdadeiro ou falso. Se for verdadeiro, a ação é executada.
• Expressões Regulares (Regex): O padrão mais comum. A regex deve
estar entre barras / /.
– /ERRO|FALHA/: Ação executa se a linha contiver “ERRO” ou
“FALHA”.
– $3 ~ /ˆID-/: Ação executa se o terceiro campo corresponder (~)
à regex (começa com “ID-”).
– $3 !~ /ˆID-/: Ação executa se o terceiro campo não corresponder
(!~).
• Expressões Relacionais: Comparações numéricas ou de string.
– NF > 5: Se o número de campos for maior que 5.
– $1 == "admin": Se o primeiro campo for exatamente “admin”.
– NR % 2 == 0: Para todas as linhas pares.

9
 • Padrões de Intervalo: Seleciona um bloco de linhas.
– /START_LOG/,/END_LOG/: Executa a ação para todas as linhas,
começando pela que contém “START_LOG” e terminando na que
contém “END_LOG”.
• Os Padrões Especiais BEGIN e END:
– BEGIN { FS=","; print "INICIANDO RELATÓRIO" }
– END { print "FIM DO RELATÓRIO. Total:", total }
• Omissão de Padrão ou Ação:
– awk '{ print $1 }': Sem padrão, a ação { print $1 } executa
para todas as linhas.
– awk '/FATAL/': Sem ação, a ação padrão é { print }. Isso é fun-
cionalmente idêntico a grep 'FATAL'.

3. As Variáveis Internas: A Caixa de Ferramentas do AWK

Estas variáveis são o que tornam o AWK consciente da estrutura dos dados.

Explicação Detalhada e
Variável Categoria Uso Estratégico
$0, $1, ... Dados $0 é a linha completa.
$1, $2, etc., são os
campos individuais.
Modificar um campo (ex:
$1 = "user")
reconstrói e modifica
$0 automaticamente
usando o OFS.
NF Metadados Número de Campos.
Essencial para validação
(if (NF != 5)) e para
acessar o último campo
de forma dinâmica
($NF).
NR Metadados Número do Registro
Global. Útil para
adicionar números de
linha ou processar
cabeçalhos (if (NR ==
1) next). next pula
para a próxima linha.

10
 Explicação Detalhada e
Variável Categoria Uso Estratégico
FNR Metadados Número do Registro
do Arquivo Atual. A
magia acontece ao
processar múltiplos
arquivos. NR == FNR é
verdadeiro apenas
enquanto o AWK
está lendo o primeiro
arquivo. Usado para
carregar dados de um
arquivo na memória
para comparar com os
seguintes.
FS Controle Separador de
Campos de Entrada.
Por padrão, um ou mais
espaços/tabs. Pode ser
qualquer regex. FS=","
para CSV. FS="[;:]"
para usar
ponto-e-vírgula ou
dois-pontos como
separador.
OFS Controle Separador de
Campos de Saída. Por
padrão, um espaço.
Mude para OFS=","
para gerar uma saída
CSV.
RS e ORS Controle Separador de
Registros. Por padrão,
nova linha. Alterar RS
para uma string vazia
(RS="") permite
processar parágrafos ou
blocos de texto
separados por linhas em
branco como um único
registro.

11
 Explicação Detalhada e
Variável Categoria Uso Estratégico
FILENAME Metadados Nome do arquivo atual.
Útil em laços END para
saber qual arquivo
acabou de ser
processado.
ARGC, ARGV Controle Argumentos da linha de
comando, como em C.
Permite manipulação
avançada dos arquivos
de entrada.

4. A Arma Secreta: Arrays Associativos

Diferente de arrays em C ou Java, os arrays do AWK são dicionários (ou
hashes). O índice não precisa ser um número; pode ser qualquer string. Esta é a
característica mais poderosa para sumarização de dados.
Cenário: Contar a frequência de IPs em um log de acesso.
[Link]:
[Link] GET /[Link]
[Link] POST /login
[Link] GET /[Link]
[Link] GET /[Link]
[Link] PUT /data
[Link] GET /[Link]
Solução com Array Associativo:
awk '{ ip_count[$1]++ } END { for (ip in ip_count) print ip, "ocorreu", ip_count[ip], "vezes
Análise do Comando:
1. { ip_count[$1]++ }: Para cada linha, usamos o primeiro campo (o IP)
como chave do array ip_count. O operador ++ incrementa o valor associ-
ado a essa chave. Se a chave não existe, o AWK a cria com valor 0 e então
a incrementa para 1.
2. END { ... }: Após processar todas as linhas, o array ip_count contém a
contagem de cada IP único.
3. for (ip in ip_count): Iteramos sobre todas as chaves (ip) que foram
armazenadas no array.
4. print ip, "ocorreu", ip_count[ip], "vezes": Imprimimos a chave
(o IP) e o valor correspondente (ip_count[ip], a contagem).

12
5. Integração com o Shell e Scripts
• One-Liners: Para tarefas simples. ps aux | awk '$3 > 1.0 {print
$2, $11}' (Imprime PID e Comando de processos usando mais de 1% de
CPU).
• Passando Variáveis do Shell (-v): A forma correta e segura de injetar
variáveis externas.
USER="admin"
awk -v user_shell="$USER" '$1 == user_shell { count++ } END { print count }' [Link]
• Scripts em Arquivo (-f): Para lógica complexa, use um arquivo .awk.
meu_script.awk:
# meu_script.awk - Relatório de Vendas
BEGIN {
FS = ";"
print "Relatório de Faturamento por Região"
print "-----------------------------------"
}

# Pula o cabeçalho do CSV

NR == 1 { next }

# Processa as linhas de dados

# Formato: id;produto;quantidade;valor_unitario;regiao
{
faturamento_regiao[$5] += $3 * $4
}

END {
for (regiao in faturamento_regiao) {
printf "Região: %-5s | Faturamento: R$ %10.2f\n", regiao, faturamento_regiao[re
}
}
Execução: awk -f meu_script.awk [Link]

13