0Pricing
DevOps Bootcamp · Lekcja

Wzorce, zakresy oraz bloki BEGIN/END

Filtruj rekordy za pomocą wzorców warunkowych oraz twórz nagłówki i podsumowania przy użyciu bloków BEGIN i END.

Wzorce, zakresy oraz bloki BEGIN/END to bezpłatna lekcja DevOps Bootcamp na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej DevOps Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs DevOps Bootcamp zawiera 4 lekcji w sumie.

Czym są wzorce awk?

W awk wzorzec to warunek określający, czy blok akcji zostanie wykonany dla danego wiersza wejściowego. Ogólna postać to:

awk 'pattern { action }' file

Jeśli wzorzec pasuje do bieżącego rekordu, akcja zostaje wykonana. Jeśli nie podano akcji, awk domyślnie wypisuje cały wiersz. Wzorce mogą być następujące:

  • Wyrażenia regularne — /regex/
  • Wyrażenia relacyjne — $3 > 100
  • Wyrażenia złożone — $1 == "ERROR" && $4 > 500
  • Wzorce zakresów — /start/,/end/
  • Wzorce specjalne — BEGIN i END

Zrozumienie wzorców otwiera drogę do używania awk jako zaawansowanego filtra danych, a nie tylko narzędzia do wypisywania kolumn.

Wzorce wyrażeń regularnych do filtrowania wierszy

Najczęściej spotykanym typem wzorca jest wyrażenie regularne ujęte w ukośniki. awk sprawdza każdy wiersz względem wyrażenia regularnego i wykonuje akcję tylko dla pasujących wierszy.

Poniżej filtrujemy plik w stylu /var/log/syslog, aby wyświetlić tylko wiersze zawierające słowo 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 }'

Wzorce zanegowane i złożone

Dodaj ! przed wzorcem wyrażenia regularnego, aby odwrócić jego działanie — dopasowywać wiersze, które nie zawierają danego wzorca. Połącz wiele warunków za pomocą && (AND) lub || (OR), aby uzyskać precyzyjną kontrolę.

  • !/DEBUG/ — pomija wiersze debugowania
  • $3 > 500 && $5 == "POST" — duże żądania POST
  • /WARN/ || /ERROR/ — dowolny z tych poziomów ważności

Poniższy przykład analizuje uproszczony dziennik dostępu i wypisuje tylko żądania POST o rozmiarze odpowiedzi większym niż 1000 bajtów:

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

Wzorce zakresów: /start/,/end/

Wzorzec zakresu wybiera ciągły blok rekordów — od wiersza pasującego do /start/ do wiersza pasującego do /end/, włącznie. Składnia wygląda następująco:

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

Najważniejsze zasady działania:

  • Zakres aktywuje się przy pierwszym wierszu pasującym do /start/ i dezaktywuje po pierwszym kolejnym wierszu pasującym do /end/.
  • Jeśli /end/ nigdy nie zostanie dopasowane, zakres pozostaje aktywny aż do końca pliku.
  • Wiele niezachodzących na siebie zakresów w tym samym pliku jest przetwarzanych niezależnie.

Dzięki temu wzorce zakresów doskonale nadają się do wyodrębniania oznaczonych sekcji z plików konfiguracyjnych, dzienników z nagłówkami rozdzielającymi oraz raportów podzielonych na wiele bloków.

Wyodrębnianie sekcji za pomocą wzorców zakresów

Rozważmy konfigurację serwera zawierającą wiele nazwanych sekcji rozdzielonych nagłówkami [section]. Chcemy uzyskać tylko wiersze znajdujące się wewnątrz sekcji [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'

Blok BEGIN

Blok BEGIN jest wykonywany raz, przed odczytaniem jakichkolwiek danych wejściowych. Doskonale nadaje się do:

  • wypisywania nagłówka raportu
  • inicjowania zmiennych i liczników
  • ustawiania separatora pól (FS) lub innych zmiennych wbudowanych
  • uruchamiania samodzielnych programów awk, które nie wymagają danych wejściowych

Składnia:

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

Ustawienie FS w sekcji BEGIN jest przejrzystą alternatywą dla flagi -F — szczególnie przydatną podczas pisania programów zawierających wiele reguł, gdy logika separatora znajduje się wewnątrz skryptu.

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

Blok END

Blok END jest wykonywany raz, po przetworzeniu ostatniego rekordu. To naturalne miejsce na:

  • wypisywanie sum, średnich i podsumowań zebranych podczas przetwarzania
  • opróżnianie buforów lub zamykanie plików wyjściowych
  • wypisywanie wierszy stopki w sformatowanych raportach

Zmienne ustawione podczas przetwarzania głównych reguł są nadal dostępne w bloku END — na tej zasadzie działają sumy narastające. Poniższy przykład sumuje wartości wynagrodzeń z pliku CSV i wypisuje sumę w stopce:

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

Łączenie BEGIN, reguł i END

Pełna moc ujawnia się, gdy połączysz wszystkie trzy bloki w jeden samodzielny program awk, który wypisuje nagłówek, przetwarza każdy rekord i wypisuje podsumowanie. Ten wzorzec stanowi podstawę potoków raportowania opartych na powłoce.

Poniżej znajduje się kompletny generator raportów, który odczytuje plik CSV z żądaniami internetowymi, wypisuje szczegóły każdego wiersza oraz końcową liczbę żądań trwających dłużej niż 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
}
'

Ustawianie OFS i ORS za pomocą BEGIN

Dwie często pomijane zmienne wyjściowe można wygodnie ustawić w sekcji BEGIN:

  • OFS (Output Field Separator) — wstawiany między polami podczas ponownego tworzenia rekordu za pomocą $1=$1 lub używania print $1, $2
  • ORS (Output Record Separator) — dodawany po każdym wywołaniu print (domyślnie ma wartość \n)

Ustawienie OFS="," pozwala jednym przebiegiem przekształcić TSV w CSV bez konkatenacji ciągów znaków. Zmiana wartości ORS na "\n---\n" automatycznie dodaje separatory między rekordami.

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

Praktyczny wzorzec zakresu: przedziały incydentów w dziennikach

Wzorce zakresów doskonale sprawdzają się w analizie dzienników operacyjnych. Częstym zadaniem jest wyodrębnienie wszystkich wierszy dziennika między początkiem a końcem incydentu, oznaczonymi komunikatami sygnalizacyjnymi, takimi jak INCIDENT START i INCIDENT END.

W poniższym przykładzie awk wyodrębnia tylko wiersze znajdujące się w przedziale incydentu i zlicza zawarte w nim zdarzenia ERROR — łącząc wzorzec zakresu, akumulator oraz podsumowanie w sekcji 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 }
'

Pomijanie wierszy rozdzielających w zakresie

Domyślnie wzorce zakresów obejmują również wiersze pasujące do /start/ i /end/. Aby pominąć te wiersze rozdzielające i zachować wyłącznie treść znajdującą się pomiędzy nimi, należy zabezpieczyć akcję negacją albo zmienną przełącznikową:

  • Podejście z negacją: /start/,/end/ { if (!/start/ && !/end/) print }
  • Podejście ze znacznikiem: ręcznie ustawiaj zmienną na 1 dla /start/ i na 0 dla /end/

Podejście ze znacznikiem jest bardziej niezawodne, gdy tekst rozdzielający może również wystąpić w treści:

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

Sprawdź wiedzę: działanie bloku BEGIN

Sprawdź swoje rozumienie tego, jak bloki BEGIN i END współdziałają z przetwarzaniem danych wejściowych w awk.

Podsumowanie lekcji: wzorce, zakresy oraz BEGIN/END

W tej lekcji opanował(a) Pan/Pani trzy najpotężniejsze cechy strukturalne programów awk:

  • Wzorce — wyrażenia regularne (/ERROR/), relacyjne ($3 > 1000), zanegowane (!/DEBUG/) i złożone (&&, ||) — określają, które rekordy uruchamiają akcję, bez potrzeby stosowania jawnych instrukcji if.
  • Wzorce zakresów (/start/,/end/) — wybierają ciągłe bloki rekordów, idealne do wyodrębniania przedziałów incydentów z dzienników, sekcji konfiguracji i fragmentów raportów. Gdy trzeba wykluczyć same wiersze rozdzielające, należy użyć zmiennej przełącznikowej (next + wartość logiczna).
  • Blok BEGIN — jest wykonywany raz przed odczytaniem danych wejściowych; idealnie nadaje się do ustawiania FS, OFS i ORS, inicjowania liczników oraz wypisywania nagłówków raportów.
  • Blok END — jest wykonywany raz po przetworzeniu wszystkich danych wejściowych; to właściwe miejsce na wypisywanie sum, średnich i stopek z użyciem zmiennych gromadzonych w głównych regułach.

Wspólnie te funkcje pozwalają pisać kompletne, samodokumentujące się programy awk, które pobierają surowy tekst i generują ustrukturyzowane, czytelne dla człowieka raporty — wszystko w jednym etapie potoku, bez plików tymczasowych i zewnętrznych narzędzi.

Często zadawane pytania

Czy lekcja „Wzorce, zakresy oraz bloki BEGIN/END” jest bezpłatna?

Tak — pełny tekst „Wzorce, zakresy oraz bloki BEGIN/END” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu DevOps Bootcamp, przejdź na CoddyKit PRO. Kurs DevOps Bootcamp zawiera 4 lekcji w sumie.

Co nauczysz się w „Wzorce, zakresy oraz bloki BEGIN/END”?

Filtruj rekordy za pomocą wzorców warunkowych oraz twórz nagłówki i podsumowania przy użyciu bloków BEGIN i END. Ćwiczysz DevOps Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć DevOps Bootcamp?

Nie wymagamy żadnego doświadczenia. DevOps Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Wzorce, zakresy oraz bloki BEGIN/END”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji DevOps Bootcamp?

Tak. Każda lekcja DevOps Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Rekordy, pola i niestandardowe separatory w awk
  2. Wzorce, zakresy oraz bloki BEGIN/END
  3. Agregowanie za pomocą tablic i grupowania w awk
  4. Funkcje awk, formatowanie printf i generowanie raportów
← Powrót do DevOps Bootcamp