# grep — Text mit regulären Ausdrücken durchsuchen

> Dateien und Streams mit grep nach Mustern durchsuchen — BRE, ERE und PCRE, rekursive Suche, Kontextzeilen und präzise Ausgabesteuerung.

Source: https://www.jpkc.com/db/cheatsheets/files-text/grep/

<!-- PROSE:intro -->
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.
<!-- PROSE:intro:end -->

## Grundlegende Suche

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

```bash
grep 'error' /var/log/syslog
```

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

```bash
grep 'TODO' app.js utils.js
```

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

```bash
grep -r 'console.log' src/
```

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

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

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

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

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

```bash
grep -w 'error' app.log
```

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

```bash
grep -x 'OK' status.txt
```

## Reguläre Ausdrücke

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

```bash
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.

```bash
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).

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

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

```bash
grep -E '^#' config.ini
```

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

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

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

```bash
grep -E 'GET|POST' access.log
```

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

```bash
grep 'version 2\.0' changelog.txt
```

## Ausgabe steuern

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

```bash
grep -n 'function' app.js
```

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

```bash
grep -c 'ERROR' app.log
```

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

```bash
grep -rl 'TODO' src/
```

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

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

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

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

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

```bash
grep -Hn 'error' *.log
```

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

```bash
grep -h 'export' src/*.js
```

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

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

## Kontextzeilen

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

```bash
grep -A 3 'Exception' error.log
```

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

```bash
grep -B 5 'FATAL' error.log
```

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

```bash
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.

```bash
grep -v '^#' config.ini
```

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

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

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

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

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

```bash
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.

```bash
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.

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

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

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

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

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

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

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

## Binär- & Spezialdateien

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

```bash
grep -a 'version' program.bin
```

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

```bash
grep -rI 'config' /opt/
```

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

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

## Pipes & Kombinieren

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

```bash
ps aux | grep 'nginx'
```

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

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

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

```bash
cat access.log | grep -c '404'
```

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

```bash
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.

```bash
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.

```bash
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.

<!-- PROSE:outro -->
## 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](https://www.gnu.org/software/grep/manual/grep.html) – vollständige Referenz zu Optionen und Regex-Syntax (englisch)
- [Wikipedia: Regulärer Ausdruck](https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck) – deutschsprachige Einführung in reguläre Ausdrücke
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [sed](https://www.jpkc.com/db/cheatsheets/files-text/sed/) – Stream-Editor, um die von grep gefundenen Zeilen zu transformieren
- [awk](https://www.jpkc.com/db/cheatsheets/files-text/awk/) – feldbasierte Verarbeitung und Auswertung passender Zeilen
- [find](https://www.jpkc.com/db/cheatsheets/files-text/find/) – Dateien nach Name und Metadaten finden und an grep übergeben