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 }' fileSe 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 —
BEGINeEND
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 }' fileComportamenti 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
awkautonomi che non richiedono input
Sintassi:
awk 'BEGIN { setup } pattern { action }' fileImpostare 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=$1o si usaprint $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 istruzioniifesplicite. - 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,OFSeORS, 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
- Record, campi e separatori personalizzati in awk
- Pattern, intervalli e blocchi BEGIN/END
- Aggregazione con array e raggruppamenti in awk
- Funzioni awk, formattazione con printf e generazione di report