0Pricing
DevOps Bootcamp · Lezione

Pattern, intervalli e blocchi BEGIN/END

Filtri i record con pattern condizionali e produca intestazioni e totali usando i blocchi BEGIN ed END.

Pattern, intervalli e blocchi BEGIN/END è una lezione DevOps Bootcamp gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento DevOps Bootcamp, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso DevOps Bootcamp include 4 lezioni in totale.

Cosa sono i pattern di awk?

In awk, un pattern è una condizione che determina se un blocco di azioni deve essere eseguito per una determinata riga di input. La forma generale è:

awk 'pattern { action }' file

Se il pattern corrisponde al record corrente, l’azione viene eseguita. Se non viene specificata alcuna azione, awk stampa per impostazione predefinita l’intera riga. I pattern possono essere:

  • Espressioni regolari — /regex/
  • Espressioni relazionali — $3 > 100
  • Espressioni composte — $1 == "ERROR" && $4 > 500
  • Pattern di intervallo — /start/,/end/
  • Pattern speciali — BEGIN e END

Comprendere i pattern è il punto di accesso all’uso di awk come potente filtro per i dati, anziché come semplice strumento per stampare colonne.

Pattern con espressioni regolari per filtrare le righe

Il tipo di pattern più comune è un’espressione regolare racchiusa tra barre. awk verifica ogni riga rispetto all’espressione regolare ed esegue l’azione solo sulle corrispondenze.

Di seguito filtriamo un file in stile /var/log/syslog per mostrare solo le righe che contengono la parola 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 }'

Pattern negati e composti

Anteponendo ! a un pattern con espressione regolare lo si nega, selezionando le righe che non contengono il pattern. È possibile combinare più condizioni con && (AND) o || (OR) per un controllo più preciso.

  • !/DEBUG/ — esclude le righe di debug
  • $3 > 500 && $5 == "POST" — richieste POST di grandi dimensioni
  • /WARN/ || /ERROR/ — uno dei due livelli di gravità

L’esempio seguente analizza un log di accesso semplificato e stampa solo le richieste POST con una dimensione della risposta superiore a 1000 byte:

#!/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 }'

Pattern di intervallo: /start/,/end/

Un pattern di intervallo seleziona un blocco contiguo di record: dalla riga che corrisponde a /start/ fino alla riga che corrisponde a /end/, estremi inclusi. La sintassi è:

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

Comportamenti importanti da conoscere:

  • L’intervallo si attiva sulla prima riga che corrisponde a /start/ e si disattiva dopo la prima riga successiva che corrisponde a /end/.
  • Se /end/ non trova mai corrispondenze, l’intervallo rimane attivo fino alla fine del file.
  • Più intervalli non sovrapposti nello stesso file vengono elaborati indipendentemente.

Questo rende i pattern di intervallo ideali per estrarre sezioni contrassegnate da file di configurazione, log con intestazioni delimitatrici o report composti da più blocchi.

Estrarre sezioni con i pattern di intervallo

Consideri una configurazione del server con più sezioni denominate, delimitate da intestazioni [section]. Vogliamo solo le righe contenute in [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'

Il blocco BEGIN

Il blocco BEGIN viene eseguito una sola volta, prima della lettura di qualsiasi input. È ideale per:

  • Stampare l’intestazione di un report
  • Inizializzare variabili e contatori
  • Impostare il separatore dei campi (FS) o altre variabili predefinite
  • Eseguire programmi awk autonomi che non richiedono input

Sintassi:

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

Impostare FS in BEGIN è l’alternativa più ordinata al flag -F, particolarmente utile quando si scrivono programmi con più regole e la logica del separatore risiede nello 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 "--------------------------------------------"
}'

Il blocco END

Il blocco END viene eseguito una sola volta, dopo l’elaborazione dell’ultimo record. È il punto naturale in cui:

  • Stampare totali, medie e riepiloghi accumulati durante l’elaborazione
  • Svuotare il buffer o chiudere i file di output
  • Stampare le righe finali dei report formattati

Le variabili impostate durante le regole principali rimangono nell’ambito di visibilità anche all’interno di END: è così che funzionano i totali progressivi. L’esempio seguente somma i valori degli stipendi da un CSV e stampa il totale nel piè di pagina:

#!/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 }
'

Combinare BEGIN, regole ed END

La vera potenza emerge quando si combinano tutti e tre i blocchi in un unico programma awk autonomo che stampa un’intestazione, elabora ogni record e stampa un riepilogo. Questo modello è alla base delle pipeline di reportistica basate sulla shell.

Di seguito è riportato un generatore di report completo che legge un CSV di richieste web e stampa i dettagli di ogni riga, oltre al conteggio finale delle richieste che hanno superato 1 secondo:

#!/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
}
'

Usare BEGIN per impostare OFS e ORS

Due variabili di output spesso trascurate possono essere impostate in modo ordinato in BEGIN:

  • OFS (Output Field Separator) — viene inserito tra i campi quando si ricostruisce un record con $1=$1 o si usa print $1, $2
  • ORS (Output Record Separator) — viene aggiunto dopo ogni chiamata a print (il valore predefinito è \n)

Impostando OFS="," è possibile riformattare un TSV in CSV in un solo passaggio, senza concatenare stringhe. Modificando ORS in "\n---\n" si aggiungono automaticamente separatori tra i record.

#!/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 }'

Pattern di intervallo pratico: intervalli di incidenti nei log

I pattern di intervallo sono particolarmente efficaci nell’analisi operativa dei log. Un’attività comune consiste nell’estrarre tutte le righe di log comprese tra l’inizio e la fine di un incidente, identificati da messaggi sentinella come INCIDENT START e INCIDENT END.

Nell’esempio seguente, awk estrae solo le righe all’interno dell’intervallo dell’incidente e conta gli eventi ERROR al suo interno, combinando un pattern di intervallo con un accumulatore e un riepilogo in 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 }
'

Escludere le righe delimitatrici da un intervallo

Per impostazione predefinita, i pattern di intervallo includono anche le righe che corrispondono a /start/ e /end/. Per ignorare queste righe delimitatrici e mantenere solo il contenuto intermedio, si può subordinare l’azione a una negazione o a una variabile di stato:

  • Approccio con negazione: /start/,/end/ { if (!/start/ && !/end/) print }
  • Approccio con flag: impostare manualmente una variabile a 1 in corrispondenza di /start/ e a 0 in corrispondenza di /end/

L’approccio con flag è più affidabile quando il testo delimitatore potrebbe comparire anche nel contenuto:

#!/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 delle conoscenze: comportamento del blocco BEGIN

Verifichi la Sua comprensione del modo in cui i blocchi BEGIN e END interagiscono con l’elaborazione dell’input in awk.

Riepilogo della lezione: pattern, intervalli e BEGIN/END

In questa lezione ha acquisito padronanza delle tre funzionalità strutturali più potenti dei programmi awk:

  • Pattern — regex (/ERROR/), relazionali ($3 > 1000), negati (!/DEBUG/) e composti (&&, ||) determinano quali record attivano un’azione senza la necessità di istruzioni if esplicite.
  • Pattern di intervallo (/start/,/end/) — selezionano blocchi contigui di record, perfetti per estrarre intervalli di incidenti dai log, sezioni di configurazione e segmenti di report. Usi una variabile di stato (next + valore booleano) quando deve escludere le righe delimitatrici.
  • Blocco BEGIN — viene eseguito una volta prima di qualsiasi input; è ideale per impostare FS, OFS e ORS, inizializzare i contatori e stampare le intestazioni dei report.
  • Blocco END — viene eseguito una volta dopo tutto l’input; è il punto corretto in cui stampare totali, medie e piè di pagina usando le variabili accumulate nelle regole principali.

Insieme, queste funzionalità consentono di scrivere programmi awk completi e autoesplicativi, che acquisiscono testo grezzo e producono report strutturati e leggibili, tutto in una singola fase della pipeline, senza file temporanei o strumenti esterni.

Domande Frequenti

La lezione «Pattern, intervalli e blocchi BEGIN/END» è gratuita?

Sì — il testo completo di «Pattern, intervalli e blocchi BEGIN/END» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso DevOps Bootcamp, passa a CoddyKit PRO. Il corso DevOps Bootcamp include 4 lezioni in totale.

Cosa imparerò in «Pattern, intervalli e blocchi BEGIN/END»?

Filtri i record con pattern condizionali e produca intestazioni e totali usando i blocchi BEGIN ed END. Eserciti DevOps Bootcamp con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare DevOps Bootcamp?

Non è richiesta alcuna esperienza precedente. DevOps Bootcamp su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Pattern, intervalli e blocchi BEGIN/END»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione DevOps Bootcamp?

Sì. Ogni lezione DevOps Bootcamp include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Record, campi e separatori personalizzati in awk
  2. Pattern, intervalli e blocchi BEGIN/END
  3. Aggregazione con array e raggruppamenti in awk
  4. Funzioni awk, formattazione con printf e generazione di report
← Torna a DevOps Bootcamp