PricingLoginStart free
DevOps-bootcamp · Les

Patronen, bereiken en BEGIN/END-blokken

Filter records met voorwaardelijke patronen en genereer kopteksten en totalen met BEGIN- en END-blokken.

Les 2 van 413 stappen

Patronen, bereiken en BEGIN/END-blokken is een gratis DevOps-bootcamp-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject DevOps-bootcamp. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus DevOps-bootcamp bevat in totaal 4 lessen.

Wat zijn awk-patronen?

In awk is een patroon een voorwaarde die bepaalt of een actieblok voor een bepaalde invoerregel wordt uitgevoerd. De algemene vorm is:

awk 'pattern { action }' file

Als het patroon overeenkomt met het huidige record, wordt de actie uitgevoerd. Als er geen actie is opgegeven, drukt awk standaard de hele regel af. Patronen kunnen het volgende zijn:

  • Reguliere expressies — /regex/
  • Relationele expressies — $3 > 100
  • Samengestelde expressies — $1 == "ERROR" && $4 > 500
  • Bereikpatronen — /start/,/end/
  • Speciale patronen — BEGIN en END

Als je patronen begrijpt, kun je awk gebruiken als krachtige gegevensfilter in plaats van alleen als programma om kolommen af te drukken.

Reguliere-expressiepatronen om regels te filteren

Het meest voorkomende type patroon is een reguliere expressie tussen schuine strepen. awk vergelijkt elke regel met de reguliere expressie en voert de actie alleen uit bij overeenkomsten.

Hieronder filteren we een bestand in de stijl van /var/log/syslog zodat alleen regels worden getoond die het woord ERROR bevatten:

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

Ontkende en samengestelde patronen

Voorzie een patroon met een reguliere expressie van ! om het om te keren: zo worden regels gevonden die het patroon niet bevatten. Combineer meerdere voorwaarden met && (EN) of || (OF) voor nauwkeurige controle.

  • !/DEBUG/ — debugregels overslaan
  • $3 > 500 && $5 == "POST" — grote POST-verzoeken
  • /WARN/ || /ERROR/ — een van beide ernstniveaus

Het onderstaande voorbeeld parseert een vereenvoudigd toegangslogboek en drukt alleen POST-verzoeken af waarvan de respons groter is dan 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 }'

Bereikpatronen: /start/,/end/

Een bereikpatroon selecteert een aaneengesloten blok records — van de regel die overeenkomt met /start/ tot en met de regel die overeenkomt met /end/. De syntaxis is:

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

Belangrijk gedrag:

  • Het bereik wordt actief op de eerste regel die overeenkomt met /start/ en wordt gedeactiveerd na de eerste daaropvolgende regel die overeenkomt met /end/.
  • Als /end/ nooit overeenkomt, blijft het bereik actief tot het einde van het bestand.
  • Meerdere niet-overlappende bereiken in hetzelfde bestand worden elk afzonderlijk verwerkt.

Daarom zijn bereikpatronen ideaal voor het extraheren van gemarkeerde secties uit configuratiebestanden, logboeken met scheidingskoppen of rapporten met meerdere blokken.

Secties extraheren met bereikpatronen

Stel dat een serverconfiguratie meerdere benoemde secties bevat die worden afgebakend door koppen als [section]. We willen alleen de regels binnen [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'

Het BEGIN-blok

Het BEGIN-blok wordt eenmalig uitgevoerd voordat er invoer wordt gelezen. Het is ideaal voor:

  • Een rapportkop afdrukken
  • Variabelen en tellers initialiseren
  • Het veldscheidingsteken (FS) of andere ingebouwde variabelen instellen
  • Zelfstandige awk-programma's uitvoeren waarvoor geen invoer nodig is

Syntaxis:

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

FS instellen in BEGIN is het nette alternatief voor de vlag -F — vooral handig bij programma's met meerdere regels, waarin de logica voor scheidingstekens in het script staat.

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

Het END-blok

Het END-blok wordt eenmalig uitgevoerd nadat het laatste record is verwerkt. Dit is de aangewezen plek om:

  • Totalen, gemiddelden en samenvattingen af te drukken die tijdens de verwerking zijn verzameld
  • Uitvoerbestanden leeg te maken of te sluiten
  • Voettekstregels voor opgemaakte rapporten af te drukken

Variabelen die tijdens de hoofdregels zijn ingesteld, zijn binnen END nog steeds binnen bereik — zo werken lopende totalen. Het onderstaande voorbeeld telt salariswaarden uit een CSV-bestand op en drukt het totaal in de voettekst af:

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

BEGIN, regels en END combineren

De echte kracht ontstaat wanneer je alle drie de blokken combineert in één zelfstandig awk-programma dat een kop afdrukt, elk record verwerkt en een samenvatting afdrukt. Dit patroon vormt de basis van rapportagepipelines in de shell.

Hieronder staat een complete rapportgenerator die een CSV-bestand met webverzoeken leest, details per regel afdrukt en tot slot telt hoeveel verzoeken langer dan 1 seconde duurden:

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

BEGIN gebruiken om OFS en ORS in te stellen

Twee vaak over het hoofd geziene uitvoervariabelen kunnen netjes in BEGIN worden ingesteld:

  • OFS (Uitvoerveldscheidingsteken) — wordt ingevoegd tussen velden wanneer je een record opnieuw opbouwt met $1=$1 of print $1, $2 gebruikt
  • ORS (Uitvoerrecordscheidingsteken) — wordt na elke aanroep van print toegevoegd (standaard is dit \n)

Met OFS="," kun je een TSV in één doorgang omzetten naar CSV zonder tekenreeksen samen te voegen. Als je ORS wijzigt naar "\n---\n", worden automatisch scheidingstekens tussen records toegevoegd.

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

Praktisch bereikpatroon: incidentvensters in logboeken

Bereikpatronen komen goed van pas bij operationele analyse van logboeken. Een veelvoorkomende taak is alle logregels tussen het begin en einde van een incident te extraheren. Deze worden aangegeven met markeerberichten zoals INCIDENT START en INCIDENT END.

In het onderstaande voorbeeld extraheert awk alleen de regels binnen het incidentvenster en telt het de ERROR-gebeurtenissen daarin — een combinatie van een bereikpatroon, een accumulator en een samenvatting 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 }
'

Scheidingstekenregels in een bereik overslaan

Bereikpatronen bevatten standaard ook de regels die zelf overeenkomen met /start/ en /end/. Als je die scheidingstekenregels wilt overslaan en alleen de inhoud ertussen wilt behouden, kun je de actie afschermen met een ontkenning of een vlagvariabele:

  • Ontkenningsaanpak: /start/,/end/ { if (!/start/ && !/end/) print }
  • Vlagaanpak: stel handmatig een variabele in op 1 bij /start/ en op 0 bij /end/

De vlagaanpak is robuuster wanneer de tekst van het scheidingsteken ook in de inhoud kan voorkomen:

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

Kennistoets: gedrag van het BEGIN-blok

Test je begrip van de manier waarop BEGIN- en END-blokken samenwerken met de invoerverwerking in awk.

Beantwoord dit in de interactieve les

Samenvatting van de les: patronen, bereiken en BEGIN/END

In deze les heb je de drie krachtigste structurele functies van awk-programma's onder de knie gekregen:

  • Patronen — reguliere expressies (/ERROR/), relationele expressies ($3 > 1000), ontkende expressies (!/DEBUG/) en samengestelde expressies (&&, ||) bepalen welke records een actie activeren zonder expliciete if-instructies.
  • Bereikpatronen (/start/,/end/) — selecteren aaneengesloten blokken records, ideaal voor het extraheren van incidentvensters uit logboeken, configuratiesecties en rapportsegmenten. Gebruik een vlagvariabele (next + boolean) wanneer je de scheidingstekenregels zelf wilt uitsluiten.
  • BEGIN-blok — wordt eenmalig uitgevoerd vóór alle invoer; ideaal voor het instellen van FS, OFS en ORS, het initialiseren van tellers en het afdrukken van rapportkoppen.
  • END-blok — wordt eenmalig uitgevoerd na alle invoer; de aangewezen plek om totalen, gemiddelden en voetteksten af te drukken met variabelen die in de hoofdregels zijn verzameld.

Met deze functies samen kun je complete, zichzelf documenterende awk-programma's schrijven die onbewerkte tekst inlezen en gestructureerde, voor mensen leesbare rapporten produceren — allemaal in één pipelinefase, zonder tijdelijke bestanden of externe hulpprogramma's.

Gratis beginnen

Leer DevOps-bootcamp met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
142
Lessen
568
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “Patronen, bereiken en BEGIN/END-blokken” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad DevOps-bootcamp, waaronder “Patronen, bereiken en BEGIN/END-blokken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus DevOps-bootcamp bevat in totaal 4 lessen.

Wat leer ik in “Patronen, bereiken en BEGIN/END-blokken”?

Filter records met voorwaardelijke patronen en genereer kopteksten en totalen met BEGIN- en END-blokken. Je oefent met DevOps-bootcamp door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met DevOps-bootcamp te beginnen?

Ervaring vooraf is niet nodig. DevOps-bootcamp op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Patronen, bereiken en BEGIN/END-blokken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over DevOps-bootcamp?

Ja. Elke les over DevOps-bootcamp bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Records, velden en aangepaste scheidingstekens in awk
  2. Patronen, bereiken en BEGIN/END-blokken
  3. Aggregatie met awk-arrays en groepering
  4. awk-functies, printf-opmaak en rapportgeneratie
← Terug naar DevOps-bootcamp