PricingLoginStart free
DevOps-bootcamp · leksjon

Mønstre, områder og BEGIN/END-blokker

Filtrer poster med betingede mønstre, og lag topptekster og totaler ved hjelp av BEGIN- og END-blokker.

Leksjon 2 av 413 trinn

Mønstre, områder og BEGIN/END-blokker er en gratis leksjon i DevOps-bootcamp på CoddyKit. Dette er leksjon 2 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i DevOps-bootcamp, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i DevOps-bootcamp inneholder totalt 4 leksjoner.

Hva er awk-mønstre?

I awk er et mønster en betingelse som avgjør om en handlingsblokk skal kjøres for en bestemt inndatalinje. Den generelle formen er:

awk 'pattern { action }' file

Hvis mønsteret samsvarer med den gjeldende posten, kjøres handlingen. Hvis ingen handling er angitt, skriver awk som standard ut hele linjen. Mønstre kan være:

  • Regulære uttrykk — /regex/
  • Relasjonelle uttrykk — $3 > 100
  • Sammensatte uttrykk — $1 == "ERROR" && $4 > 500
  • Intervallmønstre — /start/,/end/
  • Spesialmønstre — BEGIN og END

Å forstå mønstre er inngangsporten til å bruke awk som et kraftig datafilter, ikke bare som et verktøy for å skrive ut kolonner.

Regulære uttrykk som mønstre for filtrering av linjer

Den vanligste mønstertypen er et regulært uttrykk omgitt av skråstreker. awk tester hver linje mot det regulære uttrykket og kjører handlingen bare for treff.

Nedenfor filtrerer vi en fil i stil med /var/log/syslog for å vise bare linjer som inneholder ordet 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 }'

Negerte og sammensatte mønstre

Sett ! foran et regex-mønster for å invertere det — da matches linjer som ikke inneholder mønsteret. Kombiner flere betingelser med && (AND) eller || (OR) for detaljert kontroll.

  • !/DEBUG/ — hopp over feilsøkingslinjer
  • $3 > 500 && $5 == "POST" — store POST-forespørsler
  • /WARN/ || /ERROR/ — den ene eller den andre alvorlighetsgraden

Eksempelet nedenfor tolker en forenklet tilgangslogg og skriver bare ut POST-forespørsler med en svarstørrelse på over 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 }'

Intervallmønstre: /start/,/end/

Et intervallmønster velger en sammenhengende blokk med poster — fra linjen som samsvarer med /start/, til og med linjen som samsvarer med /end/. Syntaksen er:

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

Viktige egenskaper:

  • Intervallet aktiveres på den første linjen som samsvarer med /start/, og deaktiveres etter den første påfølgende linjen som samsvarer med /end/.
  • Hvis /end/ aldri gir treff, forblir intervallet aktivt til EOF.
  • Flere ikke-overlappende intervaller i samme fil behandles uavhengig av hverandre.

Dette gjør intervallmønstre ideelle for å hente ut merkede seksjoner fra konfigurasjonsfiler, logger med skilletegn i overskriftene eller rapporter med flere blokker.

Hente ut seksjoner med intervallmønstre

Tenk på en serverkonfigurasjon med flere navngitte seksjoner som avgrenses av overskrifter av typen [section]. Vi ønsker bare linjene inne i [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'

BEGIN-blokken

BEGIN-blokken kjøres én gang før noen inndata leses. Den egner seg godt til:

  • Å skrive ut en rapportoverskrift
  • Å initialisere variabler og tellere
  • Å angi feltseparatoren (FS) eller andre innebygde variabler
  • Å kjøre frittstående awk-programmer som ikke trenger inndata

Syntaks:

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

Å angi FS i BEGIN er et ryddig alternativ til flagget -F — særlig nyttig når De skriver programmer med flere regler, der separatorlogikken ligger inne i skriptet.

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

END-blokken

END-blokken kjøres én gang etter at den siste posten er behandlet. Det er det naturlige stedet å:

  • Skrive ut totaler, gjennomsnitt og sammendrag som er samlet inn under behandlingen
  • Tømme buffere eller lukke output-filer
  • Skrive ut bunntekster i formaterte rapporter

Variabler som er satt i hovedreglene, er fortsatt tilgjengelige i END — det er slik løpende totaler fungerer. Eksempelet nedenfor summerer lønnsverdier fra en CSV-fil og skriver ut totalen i bunnteksten:

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

Kombinere BEGIN, regler og END

Den virkelige kraften kommer til syne når De kombinerer alle tre blokkene i ett selvstendig awk-program som skriver ut en overskrift, behandler hver post og skriver ut et sammendrag. Dette mønsteret er selve grunnlaget for rapporteringspipelines basert på shell.

Nedenfor finner De en komplett rapportgenerator som leser en CSV-fil med webforespørsler og skriver ut detaljer per linje, samt en sluttsum for forespørsler som tok mer enn 1 sekund:

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

Bruke BEGIN til å angi OFS og ORS

To output-variabler som ofte overses, kan angis på en ryddig måte i BEGIN:

  • OFS (Output Field Separator) — settes inn mellom felt når De bygger opp en post på nytt med $1=$1 eller bruker print $1, $2
  • ORS (Output Record Separator) — legges til etter hvert print-kall (standardverdien er \n)

Ved å angi OFS="," kan De formatere en TSV-fil som CSV i én gjennomgang uten strengkonkatenering. Hvis De endrer ORS til "\n---\n", legges det automatisk til skilletegn mellom postene.

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

Praktisk intervallmønster: Tidsvinduer for hendelser i logger

Intervallmønstre er svært nyttige i operativ logganalyse. En vanlig oppgave er å hente ut alle logglinjer mellom starten og slutten av en hendelse, identifisert av markørmeldinger som INCIDENT START og INCIDENT END.

I eksempelet nedenfor henter awk bare ut linjene i hendelsesvinduet og teller ERROR-hendelsene i det — ved å kombinere et intervallmønster med en akkumulator og et END-sammendrag:

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

Hoppe over skiljelinjene i et intervall

Som standard inkluderer intervallmønstre linjene som selv samsvarer med /start/ og /end/. Hvis De vil hoppe over disse skiljelinjene og bare beholde innholdet imellom, kan De begrense handlingen med en negasjon eller en flaggvariabel:

  • Negasjonsmetoden: /start/,/end/ { if (!/start/ && !/end/) print }
  • Flaggmetoden: Sett manuelt en variabel til 1 ved /start/ og til 0 ved /end/

Flaggmetoden er mer robust når skilleteksten også kan forekomme i innholdet:

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

Kunnskapssjekk: Virkemåten til BEGIN-blokken

Test forståelsen Deres av hvordan BEGIN- og END-blokker samhandler med inndatabehandlingen i awk.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen: Mønstre, intervaller og BEGIN/END

I denne leksjonen har De fått kontroll på de tre kraftigste strukturelle funksjonene i awk-programmer:

  • Mønstre — regex (/ERROR/), relasjonelle ($3 > 1000), negerte (!/DEBUG/) og sammensatte (&&, ||) — avgjør hvilke poster som utløser en handling, uten at det er nødvendig med eksplisitte if-setninger.
  • Intervallmønstre (/start/,/end/) — velger sammenhengende blokker med poster og egner seg perfekt til å hente ut hendelsesvinduer fra logger, konfigurasjonsseksjoner og rapportsegmenter. Bruk en flaggvariabel (next + boolsk verdi) når De må utelate selve skiljelinjene.
  • BEGIN-blokken — kjøres én gang før inndata; ideell for å angi FS, OFS og ORS, initialisere tellere og skrive ut rapportoverskrifter.
  • END-blokken — kjøres én gang etter all inndata; det riktige stedet for å skrive ut totaler, gjennomsnitt og bunntekster ved hjelp av variabler som er samlet inn i hovedreglene.

Til sammen gjør disse funksjonene det mulig å skrive komplette og selvforklarende awk-programmer som tar inn råtekst og produserer strukturerte, lesbare rapporter — alt i ett enkelt trinn i pipelinen, uten midlertidige filer eller eksterne verktøy.

Gratis å komme i gang

Lær deg DevOps-bootcamp med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
142
Leksjoner
568
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Mønstre, områder og BEGIN/END-blokker» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien DevOps-bootcamp, inkludert «Mønstre, områder og BEGIN/END-blokker», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i DevOps-bootcamp inneholder totalt 4 leksjoner.

Hva lærer jeg i «Mønstre, områder og BEGIN/END-blokker»?

Filtrer poster med betingede mønstre, og lag topptekster og totaler ved hjelp av BEGIN- og END-blokker. Du øver på DevOps-bootcamp med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med DevOps-bootcamp?

Ingen tidligere erfaring er nødvendig. DevOps-bootcamp på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Mønstre, områder og BEGIN/END-blokker»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne DevOps-bootcamp-leksjonen?

Ja. Alle DevOps-bootcamp-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Poster, felt og egendefinerte skilletegn i awk
  2. Mønstre, områder og BEGIN/END-blokker
  3. Aggregering med awk-tabeller og gruppering
  4. awk-funksjoner, printf-formatering og rapportgenerering
← Tilbake til DevOps-bootcamp