0Pricing
Linux Command Line & Bash Scripting Mastery · Aula

Padrões, intervalos e blocos BEGIN/END

Filtre registros com padrões condicionais e gere cabeçalhos e totais usando blocos BEGIN e END.

Padrões, intervalos e blocos BEGIN/END é uma aula grátis de Linux Command Line & Bash Scripting Mastery no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Linux Command Line & Bash Scripting Mastery, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Linux Command Line & Bash Scripting Mastery inclui 4 aulas no total.

O que são padrões do awk?

Em awk, um padrão é uma condição que controla se um bloco de ação será executado para determinada linha de entrada. A forma geral é:

awk 'pattern { action }' file

Se o padrão corresponder ao registro atual, a ação será executada. Se nenhuma ação for fornecida, awk imprimirá a linha inteira por padrão. Os padrões podem ser:

  • Expressões regulares — /regex/
  • Expressões relacionais — $3 > 100
  • Expressões compostas — $1 == "ERROR" && $4 > 500
  • Padrões de intervalo — /start/,/end/
  • Padrões especiais — BEGIN e END

Entender os padrões é a porta de entrada para usar o awk como um filtro de dados poderoso, em vez de apenas um impressor de colunas.

Padrões de expressões regulares para filtrar linhas

O tipo de padrão mais comum é uma expressão regular entre barras. O awk testa cada linha em relação à expressão regular e executa a ação somente nas correspondências.

Abaixo, filtramos um arquivo no estilo de /var/log/syslog para mostrar somente as linhas que contêm a palavra ERROR:

#!/usr/bin/env bash
# Simulate a log file and filter ERROR lines
log=$(cat <<'EOF'
2026-06-11 08:01:22 INFO  service started
2026-06-11 08:02:05 ERROR disk quota exceeded on /dev/sda1
2026-06-11 08:02:44 WARN  memory usage at 80%
2026-06-11 08:03:10 ERROR connection timeout to 10.0.0.5
2026-06-11 08:03:55 INFO  backup completed
EOF
)

echo "=== ERROR lines only ==="
echo "$log" | awk '/ERROR/ { print NR": "$0 }'

Padrões negados e compostos

Coloque ! antes de um padrão de expressão regular para invertê-lo, fazendo a correspondência com as linhas que não contêm o padrão. Combine várias condições com && (AND) ou || (OR) para obter um controle detalhado.

  • !/DEBUG/ — ignorar linhas de depuração
  • $3 > 500 && $5 == "POST" — solicitações POST grandes
  • /WARN/ || /ERROR/ — qualquer uma das gravidades

O exemplo abaixo analisa um registro de acesso simplificado e imprime somente as solicitações POST com tamanho de resposta acima de 1000 bytes:

#!/usr/bin/env bash
access=$(cat <<'EOF'
10.0.0.1 GET  /api/ping     200  48
10.0.0.2 POST /api/upload   201  2048
10.0.0.3 GET  /api/users    200  512
10.0.0.4 POST /api/data     200  3500
10.0.0.5 POST /api/health   200  60
EOF
)

echo "Large POST requests (>1000 bytes):"
echo "$access" | awk '$2 == "POST" && $5 > 1000 { print $1, $3, "size="$5 }'

Padrões de intervalo: /start/,/end/

Um padrão de intervalo seleciona um bloco contíguo de registros — desde a linha correspondente a /start/ até a linha correspondente a /end/, inclusive. A sintaxe é:

awk '/start/,/end/ { action }' file

Comportamentos importantes:

  • O intervalo é ativado na primeira linha correspondente a /start/ e desativado após a primeira linha subsequente correspondente a /end/.
  • Se /end/ nunca corresponder, o intervalo permanecerá ativo até EOF.
  • Vários intervalos sem sobreposição no mesmo arquivo são processados de forma independente.

Isso torna os padrões de intervalo ideais para extrair seções marcadas de arquivos de configuração, registros com cabeçalhos delimitadores ou relatórios com vários blocos.

Extraindo seções com padrões de intervalo

Considere uma configuração de servidor que tenha várias seções nomeadas, delimitadas por cabeçalhos [section]. Queremos somente as linhas dentro de [database]:

#!/usr/bin/env bash
config=$(cat <<'EOF'
[server]
host = 0.0.0.0
port = 8080

[database]
host = 127.0.0.1
port = 5432
name = appdb
user = admin

[cache]
host = 127.0.0.1
port = 6379
EOF
)

echo "=== [database] section ==="
echo "$config" | awk '/\[database\]/,/^\[/' \
  | awk 'NR > 1 && !/^\[/ && NF'

O bloco BEGIN

O bloco BEGIN é executado uma vez, antes da leitura de qualquer entrada. Ele é ideal para:

  • Imprimir um cabeçalho de relatório
  • Inicializar variáveis e contadores
  • Definir o separador de campos (FS) ou outras variáveis integradas
  • Executar programas awk independentes que não precisam de entrada

Sintaxe:

awk 'BEGIN { setup } pattern { action }' file

Definir FS em BEGIN é a alternativa mais clara à opção -F, especialmente ao escrever programas com várias regras, nos quais a lógica do separador fica dentro do script.

#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)

echo "$csv" | awk 'BEGIN {
  FS = ","
  printf "%-10s %-15s %10s\n", "Name", "Department", "Salary"
  print "--------------------------------------------"
}'

O bloco END

O bloco END é executado uma vez, depois que o último registro é processado. Ele é o local natural para:

  • Imprimir totais, médias e resumos acumulados durante o processamento
  • Esvaziar o conteúdo pendente ou fechar arquivos de saída
  • Imprimir linhas de rodapé para relatórios formatados

As variáveis definidas durante as regras principais continuam no escopo dentro de END — é assim que funcionam os totais acumulados. O exemplo abaixo soma valores de salários de um CSV e imprime o total no rodapé:

#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)

echo "$csv" | awk -F',' '
  { total += $3; count++ }
  END { printf "Employees: %d  Total payroll: $%d\n", count, total }
'

Combinando BEGIN, regras e END

O verdadeiro poder surge quando você combina os três blocos em um único programa awk autocontido que imprime um cabeçalho, processa cada registro e imprime um resumo. Esse padrão é a base dos pipelines de geração de relatórios em shell.

Abaixo está um gerador de relatórios completo que lê um CSV de solicitações da Web e imprime detalhes por linha, além da contagem final de solicitações que excederam 1 segundo:

#!/usr/bin/env bash
data=$(cat <<'EOF'
/api/ping,0.03
/api/users,1.45
/api/login,0.88
/api/upload,2.10
/api/health,0.02
/api/report,1.73
EOF
)

echo "$data" | awk -F',' '
BEGIN {
  printf "%-20s %10s %s\n", "Endpoint", "Latency(s)", "Status"
  print "--------------------------------------"
}
{
  status = ($2 > 1.0) ? "SLOW" : "OK"
  if (status == "SLOW") slow++
  printf "%-20s %10s %s\n", $1, $2, status
}
END {
  print "--------------------------------------"
  printf "Slow requests: %d / %d\n", slow, NR
}
'

Usando BEGIN para definir OFS e ORS

Duas variáveis de saída frequentemente ignoradas podem ser definidas de forma clara em BEGIN:

  • OFS (separador de campos de saída) — inserido entre os campos quando você reconstrói um registro com $1=$1 ou usa print $1, $2
  • ORS (separador de registros de saída) — adicionado ao final de cada chamada de print (o padrão é \n)

Definir OFS="," permite reformular um TSV como CSV em uma única passagem, sem concatenação de strings. Alterar ORS para "\n---\n" adiciona separadores entre os registros automaticamente.

#!/usr/bin/env bash
# Convert whitespace-delimited data to CSV with a header
data=$(cat <<'EOF'
alice   engineering  95000
bob     marketing    72000
carol   engineering  105000
EOF
)

echo "$data" | awk 'BEGIN { OFS=","; print "name,dept,salary" }
{ $1=$1; print }'

Padrão de intervalo prático: janelas de incidentes em registros

Os padrões de intervalo são especialmente úteis na análise operacional de registros. Uma tarefa comum é extrair todas as linhas de registro entre o início e o fim de um incidente, identificados por mensagens sentinela como INCIDENT START e INCIDENT END.

No exemplo abaixo, o awk extrai somente as linhas dentro da janela do incidente e conta os eventos ERROR dentro dela, combinando um padrão de intervalo com um acumulador e um resumo em END:

#!/usr/bin/env bash
log=$(cat <<'EOF'
08:00:01 INFO  Normal operation
08:01:00 INFO  INCIDENT START: disk pressure detected
08:01:05 ERROR write failed on /dev/sda1
08:01:09 ERROR inode table corruption
08:01:14 WARN  remounting read-only
08:01:22 INFO  INCIDENT END: disk replaced
08:02:00 INFO  Normal operation resumed
EOF
)

echo "$log" | awk '
/INCIDENT START/,/INCIDENT END/ {
  print
  if (/ERROR/) errors++
}
END { print "Errors during incident:", errors+0 }
'

Ignorando as linhas delimitadoras em um intervalo

Por padrão, os padrões de intervalo incluem as próprias linhas correspondentes a /start/ e /end/. Para ignorar essas linhas delimitadoras e manter somente o conteúdo entre elas, proteja a ação com uma negação ou uma variável de sinalização:

  • Abordagem com negação: /start/,/end/ { if (!/start/ && !/end/) print }
  • Abordagem com sinalização: defina manualmente uma variável como 1 em /start/ e como 0 em /end/

A abordagem com sinalização é mais robusta quando o texto delimitador também pode aparecer no conteúdo do corpo:

#!/usr/bin/env bash
doc=$(cat <<'EOF'
## preamble
some intro text
## BEGIN_REPORT
row1: alpha 100
row2: beta  200
row3: gamma 150
## END_REPORT
## appendix
EOF
)

echo "$doc" | awk '
/## BEGIN_REPORT/ { capture=1; next }
/## END_REPORT/   { capture=0 }
capture           { print }
'

Verificação de conhecimento: comportamento do bloco BEGIN

Teste sua compreensão de como os blocos BEGIN e END interagem com o processamento da entrada no awk.

Recapitulação da lição: padrões, intervalos e BEGIN/END

Nesta lição, você dominou os três recursos estruturais mais poderosos dos programas awk:

  • Padrões — expressão regular (/ERROR/), relacional ($3 > 1000), negado (!/DEBUG/) e composto (&&, ||) — controlam quais registros acionam uma ação sem exigir instruções if explícitas.
  • Padrões de intervalo (/start/,/end/) — selecionam blocos contíguos de registros, sendo perfeitos para extrair janelas de incidentes de registros, seções de configuração e segmentos de relatórios. Use uma variável de sinalização (next + booleano) quando precisar excluir as próprias linhas delimitadoras.
  • Bloco BEGIN — executado uma vez antes de qualquer entrada; ideal para definir FS, OFS e ORS, inicializar contadores e imprimir cabeçalhos de relatórios.
  • Bloco END — executado uma vez após toda a entrada; é o local adequado para imprimir totais, médias e rodapés usando as variáveis acumuladas nas regras principais.

Juntos, esses recursos permitem escrever programas awk completos e autoexplicativos, que ingerem texto bruto e produzem relatórios estruturados e legíveis para humanos, tudo em uma única etapa do pipeline, sem arquivos temporários nem ferramentas externas.

Perguntas Frequentes

A aula “Padrões, intervalos e blocos BEGIN/END” é grátis?

Sim — o texto completo de “Padrões, intervalos e blocos BEGIN/END” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Linux Command Line & Bash Scripting Mastery, atualize para CoddyKit PRO. O curso de Linux Command Line & Bash Scripting Mastery inclui 4 aulas no total.

O que vou aprender em “Padrões, intervalos e blocos BEGIN/END”?

Filtre registros com padrões condicionais e gere cabeçalhos e totais usando blocos BEGIN e END. Você pratica Linux Command Line & Bash Scripting Mastery com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Linux Command Line & Bash Scripting Mastery?

Nenhuma experiência prévia é necessária. Linux Command Line & Bash Scripting Mastery no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Padrões, intervalos e blocos BEGIN/END”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Linux Command Line & Bash Scripting Mastery?

Sim. Cada aula de Linux Command Line & Bash Scripting Mastery inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Registros, campos e separadores personalizados no awk
  2. Padrões, intervalos e blocos BEGIN/END
  3. Agregação com matrizes e agrupamento no awk
  4. Funções do awk, formatação com printf e geração de relatórios
← Voltar para Linux Command Line & Bash Scripting Mastery