0Pricing
Linux Command Line & Bash Scripting Mastery · 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 Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery, passa a CoddyKit PRO. Il corso Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery?

Non è richiesta alcuna esperienza precedente. Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery?

Sì. Ogni lezione Linux Command Line & Bash Scripting Mastery 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 Linux Command Line & Bash Scripting Mastery