grep — Text mit regulären Ausdrücken durchsuchen

grep ist dein Standardwerkzeug zum Finden von Text. Es durchsucht Dateien oder Pipe-Eingaben Zeile für Zeile und gibt jede Zeile aus, die zu einem Muster passt – von einer einfachen Zeichenkette bis zu einem vollständigen regulären Ausdruck. Du greifst täglich dutzendfach darauf zurück: beim Durchforsten von Logdateien, beim Suchen in einer Codebasis, beim Filtern der Ausgabe eines anderen Befehls oder beim Prüfen einer Bedingung in einem Skript über den Exit-Code. Dieser Guide zeigt dir die Optionen, die wirklich zählen – Groß-/Kleinschreibung ignorieren, Wortgrenzen, rekursive Suche, die drei Regex-Varianten (-E, -P, -F), Kontextzeilen und Ausgabesteuerung.

Grundlegende Suche

grep '<pattern>' <file> — Sucht ein Muster in einer Datei und gibt passende Zeilen aus.

grep 'error' /var/log/syslog

grep '<pattern>' <file1> <file2> — Sucht ein Muster in mehreren Dateien.

grep 'TODO' app.js utils.js

grep -r '<pattern>' <path> — Durchsucht ein Verzeichnis rekursiv über alle Dateien.

grep -r 'console.log' src/

grep -R '<pattern>' <path> — Durchsucht rekursiv und folgt dabei symbolischen Links.

grep -R 'import' /usr/local/lib/

grep -i '<pattern>' <file> — Suche ohne Beachtung der Groß-/Kleinschreibung.

grep -i 'warning' /var/log/syslog

grep -w '<pattern>' <file> — Findet nur ganze Wörter (keine Teilzeichenketten).

grep -w 'error' app.log

grep -x '<pattern>' <file> — Findet nur Zeilen, die komplett auf das Muster passen.

grep -x 'OK' status.txt

Reguläre Ausdrücke

grep -E '<pattern>' <file> — Nutzt erweiterte reguläre Ausdrücke (ERE) — unterstützt +, ?, |, () ohne Escaping.

grep -E 'error|warning|fatal' app.log

grep -P '<pattern>' <file> — Nutzt Perl-kompatible reguläre Ausdrücke (PCRE) — unterstützt Lookahead, Lookbehind, \d usw.

grep -P '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}' access.log

grep -F '<string>' <file> — Behandelt das Muster als feste Zeichenkette statt als Regex (schneller bei literalen Treffern).

grep -F '$(document).ready' app.js

grep -E '^<pattern>' <file> — Findet Zeilen, die mit einem Muster beginnen.

grep -E '^#' config.ini

grep -E '<pattern>$' <file> — Findet Zeilen, die mit einem Muster enden.

grep -E '\.js$' filelist.txt

grep -E '<a>|<b>' <file> — Findet Zeilen, die das eine oder das andere Muster enthalten (Alternation).

grep -E 'GET|POST' access.log

grep '\.<ext>' <file> — Maskiert Regex-Sonderzeichen mit Backslash für einen literalen Treffer.

grep 'version 2\.0' changelog.txt

Ausgabe steuern

grep -n '<pattern>' <file> — Zeigt Zeilennummern neben den passenden Zeilen an.

grep -n 'function' app.js

grep -c '<pattern>' <file> — Zählt die Anzahl der passenden Zeilen.

grep -c 'ERROR' app.log

grep -l '<pattern>' <files> — Gibt nur die Dateinamen aus, die einen Treffer enthalten.

grep -rl 'TODO' src/

grep -L '<pattern>' <files> — Gibt nur die Dateinamen aus, die keinen Treffer enthalten.

grep -rL 'use strict' src/*.js

grep -o '<pattern>' <file> — Gibt nur den passenden Teil jeder Zeile aus, nicht die ganze Zeile.

grep -oE '[0-9]+\.[0-9]+\.[0-9]+' version.txt

grep -H '<pattern>' <file> — Gibt bei jedem Treffer immer den Dateinamen mit aus.

grep -Hn 'error' *.log

grep -h '<pattern>' <files> — Unterdrückt die Dateinamen in der Ausgabe bei der Suche in mehreren Dateien.

grep -h 'export' src/*.js

grep --color=always '<pattern>' <file> — Hebt Treffer farbig hervor (nützlich beim Durchleiten durch less).

grep --color=always 'error' app.log | less -R

Kontextzeilen

grep -A <n> '<pattern>' <file> — Zeigt n Zeilen nach jedem Treffer.

grep -A 3 'Exception' error.log

grep -B <n> '<pattern>' <file> — Zeigt n Zeilen vor jedem Treffer.

grep -B 5 'FATAL' error.log

grep -C <n> '<pattern>' <file> — Zeigt n Zeilen vor und nach jedem Treffer (Kontext).

grep -C 2 'segfault' /var/log/kern.log

Invertieren & Filtern

grep -v '<pattern>' <file> — Invertiert die Suche — gibt Zeilen aus, die nicht auf das Muster passen.

grep -v '^#' config.ini

grep -v -e '<a>' -e '<b>' <file> — Schließt Zeilen aus, die auf eines von mehreren Mustern passen.

grep -v -e '^#' -e '^$' config.ini

grep -e '<a>' -e '<b>' <file> — Findet Zeilen, die eines von mehreren Mustern enthalten.

grep -e 'error' -e 'warning' app.log

grep -f <patternfile> <file> — Liest Muster aus einer Datei (ein Muster pro Zeile).

grep -f keywords.txt document.txt

Rekursive Optionen

grep -r --include='<glob>' '<pattern>' <path> — Durchsucht rekursiv, aber nur Dateien, die auf ein Glob-Muster passen.

grep -r --include='*.php' 'require_once' /var/www/

grep -r --exclude='<glob>' '<pattern>' <path> — Durchsucht rekursiv, überspringt aber Dateien, die auf ein Glob-Muster passen.

grep -r --exclude='*.min.js' 'function' src/

grep -r --include='*.{js,ts}' '<pattern>' <path> — Durchsucht rekursiv in mehreren Dateitypen per Brace-Expansion.

grep -r --include='*.{js,ts}' 'import' src/

grep -r --exclude-dir='<dir>' '<pattern>' <path> — Durchsucht rekursiv, überspringt aber bestimmte Verzeichnisse.

grep -r --exclude-dir='node_modules' 'TODO' .

grep -r --exclude-dir={<a>,<b>} '<pattern>' <path> — Überspringt mehrere Verzeichnisse bei der rekursiven Suche.

grep -r --exclude-dir={node_modules,.git,dist} 'console' .

Binär- & Spezialdateien

grep -a '<pattern>' <file> — Behandelt Binärdateien als Text.

grep -a 'version' program.bin

grep -I '<pattern>' <file> — Überspringt Binärdateien vollständig (behandelt sie als nicht passend).

grep -rI 'config' /opt/

grep -Z '<pattern>' <files> — Gibt nach jedem Dateinamen ein Nullbyte aus (zur Verwendung mit xargs -0).

grep -rlZ 'TODO' src/ | xargs -0 sed -i 's/TODO/DONE/g'

Pipes & Kombinieren

<command> | grep '<pattern>' — Filtert die Ausgabe eines anderen Befehls.

ps aux | grep 'nginx'

<command> | grep -v 'grep' — Filtert die Ausgabe und schließt den grep-Prozess selbst aus den Ergebnissen aus.

ps aux | grep 'nginx' | grep -v 'grep'

<command> | grep -c '<pattern>' — Zählt passende Zeilen aus der Pipe-Eingabe.

cat access.log | grep -c '404'

grep '<a>' <file> | grep '<b>' — Verkettet grep-Befehle, um Zeilen zu finden, die beide Muster enthalten (UND-Logik).

grep 'ERROR' app.log | grep 'database'

<command> | grep -q '<pattern>' && echo 'found' — Stiller Modus — unterdrückt die Ausgabe und nutzt den Exit-Code in Skripten.

grep -q 'root' /etc/passwd && echo 'root user exists'

Praxisbeispiele

grep -rn 'TODO\|FIXME\|HACK' src/ — Findet alle TODO-, FIXME- und HACK-Kommentare im Quellcode mit Zeilennummern.

grep -rl 'old_function' src/ | xargs sed -i 's/old_function/new_function/g' — Findet und ersetzt eine Zeichenkette über alle passenden Dateien hinweg.

grep -oP '(?<=href=")[^"]+' index.html — Extrahiert alle URLs aus href-Attributen per PCRE-Lookbehind.

grep -E '^[0-9]{1,3}(\.[0-9]{1,3}){3}' access.log | sort | uniq -c | sort -rn | head — Zählt und sortiert IP-Adressen in einer Logdatei.

grep -Pzo '(?s)<div class="content">.*?</div>' page.html — Findet ein mehrzeiliges Muster per PCRE mit null-terminierter Ausgabe.

grep -r --include='*.env' -l 'PASSWORD' . — Findet Umgebungsdateien, die Passwort-Referenzen enthalten.

grep -cE '^(import|from)' src/*.py | sort -t: -k2 -rn — Zählt Import-Anweisungen pro Python-Datei, sortiert nach Anzahl.

grep -B2 -A5 'function.*login' auth.js — Zeigt den Kontext rund um eine Funktionsdefinition.

zgrep '<pattern>' <file.gz> — Sucht in gzip-komprimierten Dateien, ohne sie zu entpacken.

zgrep 'error' /var/log/syslog.2.gz

grep -rn --include='*.{css,scss}' 'z-index' src/ — Findet alle z-index-Deklarationen über CSS- und SCSS-Dateien hinweg.

Fazit

grep verdient seinen festen Platz im Alltag, weil es schnell, kombinierbar und berechenbar ist: Wähle die passende Regex-Variante (-F für literale Treffer, -E für erweiterte, -P für Perl-Features), ergänze -r für rekursive Suche und forme die Ausgabe mit -n, -o oder -c. grep selbst liest nur – es verändert deine Dateien nie –, die eigentliche Vorsicht gilt also dem, wohin du die Treffer weiterleitest, etwa grep -rlZ … | xargs -0 sed -i …, das Dateien direkt überschreibt. Beachte: -P (PCRE) ist eine GNU-Erweiterung und steht im BSD-/macOS-grep nicht zur Verfügung; dort installierst du GNU-grep (als ggrep) oder weichst auf -E aus.

Weiterführende Links

GNU-grep-Handbuch – vollständige Referenz zu Optionen und Regex-Syntax (englisch)
Wikipedia: Regulärer Ausdruck – deutschsprachige Einführung in reguläre Ausdrücke