Linux-kommandolinjen og Bash-scripting på ekspertniveau · Lektion

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

Filtrér poster med betingede mønstre, og generér overskrifter og totaler ved hjælp af BEGIN- og END-blokke.

Lektion 2 af 413 trin

Mønstre, områder og BEGIN/END-blokke er en gratis Linux-kommandolinjen og Bash-scripting på ekspertniveau-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Linux-kommandolinjen og Bash-scripting på ekspertniveau, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Linux-kommandolinjen og Bash-scripting på ekspertniveau-kurset indeholder 4 lektioner i alt.

Hvad er awk-mønstre?

I awk er et mønster en betingelse, der styrer, om en handlingsblok udføres for en given inputlinje. Den generelle form er:

awk 'pattern { action }' file

Hvis mønsteret matcher den aktuelle post, udføres handlingen. Hvis der ikke er angivet en handling, udskriver awk som standard hele linjen. Mønstre kan være:

  • Regulære udtryk — /regex/
  • Relationelle udtryk — $3 > 100
  • Sammensatte udtryk — $1 == "ERROR" && $4 > 500
  • Intervalmønstre — /start/,/end/
  • Specielle mønstre — BEGIN og END

Forståelse af mønstre er indgangen til at bruge awk som et effektivt datafilter i stedet for blot som en kolonneudskriver.

Regulære udtryksmønstre til filtrering af linjer

Den mest almindelige mønstertype er et regulært udtryk omgivet af skråstreger. awk tester hver linje mod det regulære udtryk og udfører kun handlingen for match.

Nedenfor filtrerer vi en fil i stil med /var/log/syslog, så den kun viser linjer, der indeholder 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 }'

Negerede og sammensatte mønstre

Sæt ! foran et regulært udtryksmønster for at invertere det — så matcher det linjer, der ikke indeholder mønsteret. Kombinér flere betingelser med && (OG) eller || (ELLER) for finkornet kontrol.

  • !/DEBUG/ — spring debuglinjer over
  • $3 > 500 && $5 == "POST" — store POST-anmodninger
  • /WARN/ || /ERROR/ — den ene eller den anden alvorlighedsgrad

Eksemplet nedenfor fortolker en forenklet adgangslog og udskriver kun POST-anmodninger med en svarstørrelse over 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 }'

Intervalmønstre: /start/,/end/

Et intervalmønster udvælger en sammenhængende blok af poster — fra den linje, der matcher /start/, til og med den linje, der matcher /end/. Syntaksen er:

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

Vigtige egenskaber:

  • Intervallet aktiveres på den første linje, der matcher /start/, og deaktiveres efter den første efterfølgende linje, der matcher /end/.
  • Hvis /end/ aldrig matcher, forbliver intervallet aktivt indtil EOF.
  • Flere ikke-overlappende intervaller i den samme fil behandles hver for sig.

Det gør intervalmønstre ideelle til at udtrække markerede sektioner fra konfigurationsfiler, logge med skilletekstrubrikker eller rapporter med flere blokke.

Udtrækning af sektioner med intervalmønstre

Forestil dig en serverkonfiguration med flere navngivne sektioner afgrænset af [section]-rubrikker. Vi vil kun have linjerne 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 kører én gang, før noget input læses. Den er velegnet til:

  • At udskrive en rapportcentreret overskrift
  • At initialisere variabler og tællere
  • At indstille feltseparatoren (FS) eller andre indbyggede variabler
  • At køre selvstændige awk-programmer, der ikke behøver input

Syntaks:

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

At indstille FS i BEGIN er det rene alternativ til flaget -F — især nyttigt, når du skriver programmer med flere regler, hvor separatorlogikken ligger i scriptet.

#!/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 kører én gang, efter den sidste post er behandlet. Det er det naturlige sted at:

  • Udskrive totaler, gennemsnit og opsummeringer, der er samlet under behandlingen
  • Tømme buffere eller lukke outputfiler
  • Udskrive bundlinjer til formaterede rapporter

Variabler, der er indstillet under hovedreglerne, er stadig inden for samme gyldighedsområde i END — sådan fungerer løbende totaler. Eksemplet nedenfor summerer lønværdier fra en CSV-fil og udskriver totalen i bundteksten:

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

Kombination af BEGIN, regler og END

Den virkelige styrke viser sig, når du kombinerer alle tre blokke i ét selvstændigt awk-program, der udskriver en overskrift, behandler hver post og udskriver en opsummering. Dette mønster er grundlaget for shell-baserede rapporteringspipelines.

Nedenfor er en komplet rapportgenerator, der læser en CSV-fil med webanmodninger og udskriver detaljer for hver linje samt et endeligt antal anmodninger, der oversteg 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
}
'

Brug af BEGIN til at indstille OFS og ORS

To ofte oversete outputvariabler kan indstilles på en enkel måde i BEGIN:

  • OFS (outputfeltseparator) — indsættes mellem felter, når du genopbygger en post med $1=$1 eller bruger print $1, $2
  • ORS (outputpostseparator) — tilføjes efter hvert print-kald (standardværdien er \n)

Hvis du indstiller OFS=",", kan du omformatere TSV til CSV i én gennemgang uden strengsammensætning. Hvis du ændrer ORS til "\n---\n", tilføjes der automatisk skilletegn mellem poster.

#!/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 intervalmønster: Hændelsesintervaller i logge

Intervalmønstre er særligt nyttige i analyse af driftslogge. En almindelig opgave er at udtrække alle loglinjer mellem begyndelsen og slutningen af en hændelse, identificeret af markørbeskeder som INCIDENT START og INCIDENT END.

I eksemplet nedenfor udtrækker awk kun linjerne i hændelsesintervallet og tæller ERROR-hændelserne i det — en kombination af et intervalmønster, en akkumulator og en END-opsummering:

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

Springe skiljelinjerne over i et interval

Som standard inkluderer intervalmønstre de linjer, der selv matcher /start/ og /end/. Hvis du vil springe disse skiljelinjer over og kun beholde indholdet imellem dem, skal du beskytte handlingen med en negation eller en flagvariabel:

  • Negationstilgang: /start/,/end/ { if (!/start/ && !/end/) print }
  • Flagtilgang: Indstil manuelt en variabel til 1 ved /start/ og til 0 ved /end/

Flagtilgangen er mere robust, når skilleteksten også kan forekomme i brødteksten:

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

Videnstjek: BEGIN-blokkens adfærd

Test din forståelse af, hvordan BEGIN- og END-blokke fungerer sammen med inputbehandlingen i awk.

Opsummering af lektionen: Mønstre, intervaller og BEGIN/END

I denne lektion har du lært de tre mest effektive strukturelle funktioner i awk-programmer:

  • Mønstre — regulære udtryk (/ERROR/), relationelle udtryk ($3 > 1000), negerede udtryk (!/DEBUG/) og sammensatte udtryk (&&, ||) styrer, hvilke poster der udløser en handling, uden at du behøver eksplicitte if-instruktioner.
  • Intervalmønstre (/start/,/end/) udvælger sammenhængende blokke af poster og er perfekte til at udtrække hændelsesintervaller fra logge, konfigurationssektioner og rapportafsnit. Brug en flagvariabel (next + boolsk værdi), når du skal udelade selve skiljelinjerne.
  • BEGIN-blokken — kører én gang før alt input og er ideel til at indstille FS, OFS og ORS, initialisere tællere og udskrive rapportoverskrifter.
  • END-blokken — kører én gang efter alt input og er det rette sted at udskrive totaler, gennemsnit og bundtekster ved hjælp af variabler, der er samlet i hovedreglerne.

Tilsammen lader disse funktioner dig skrive komplette, selvforklarende awk-programmer, der indlæser rå tekst og genererer strukturerede, letlæselige rapporter — alt sammen i ét pipeline-trin uden midlertidige filer eller eksterne værktøjer.

Gratis at komme i gang

Lær Bash med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
22
Lektioner
88

Ofte stillede spørgsmål

Er lektionen “Mønstre, områder og BEGIN/END-blokke” gratis?

Ja — hele teksten til “Mønstre, områder og BEGIN/END-blokke” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Linux-kommandolinjen og Bash-scripting på ekspertniveau-kurset, skal du opgradere til CoddyKit PRO. Linux-kommandolinjen og Bash-scripting på ekspertniveau-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Mønstre, områder og BEGIN/END-blokke”?

Filtrér poster med betingede mønstre, og generér overskrifter og totaler ved hjælp af BEGIN- og END-blokke. Du øver dig i Linux-kommandolinjen og Bash-scripting på ekspertniveau med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Linux-kommandolinjen og Bash-scripting på ekspertniveau?

Der kræves ingen tidligere erfaring. Linux-kommandolinjen og Bash-scripting på ekspertniveau på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Mønstre, områder og BEGIN/END-blokke”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Linux-kommandolinjen og Bash-scripting på ekspertniveau-lektion?

Ja. Alle Linux-kommandolinjen og Bash-scripting på ekspertniveau-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Poster, felter og brugerdefinerede separatorer i awk
  2. Mønstre, områder og BEGIN/END-blokke
  3. Aggregering med awk-arrays og gruppering
  4. awk-funktioner, printf-formatering og rapportgenerering
← Tilbage til Linux-kommandolinjen og Bash-scripting på ekspertniveau