Bedingungen

if, elif, else, fi

Die Grundsyntax einer Bash-Bedingung sieht so aus:

if befehl; then
    echo "Befehl war erfolgreich"
elif anderer_befehl; then
    echo "Zweiter Zweig"
else
    echo "Keiner der Zweige hat gegriffen"
fi

Das Strichpunkt vor then ist nötig, weil if und then sonst auf der gleichen Zeile als zwei separate Statements gelesen würden. Alternativ kann then auf einer eigenen Zeile stehen, dann entfällt der Strichpunkt.

Entscheidend ist: Hinter if steht kein boolescher Ausdruck, sondern ein Befehl. Bash führt diesen Befehl aus und prüft seinen Exit-Code:

• Exit-Code 0 bedeutet “wahr” (Erfolg).
• Jeder andere Exit-Code (typisch 1, aber auch 2, 127 usw.) bedeutet “falsch”.

Das ist die umgekehrte Konvention zu C, Python oder JavaScript — dort gilt 0 als falsch. In der Shell ist 0 der Erfolgswert, weil ein Programm nur eine einzige Erfolgsart kennt, aber viele Fehlerarten haben kann.

if grep -q "ERROR" log.txt; then
    echo "Fehler gefunden"
else
    echo "Alles sauber"
fi

Alles sauber

grep -q gibt nichts auf stdout aus, sondern signalisiert nur über den Exit-Code, ob das Muster gefunden wurde. Genau so sind Shell-Bedingungen gedacht: Der Befehl ist die Wahrheit.

test, [ ] und [[ ]]

Wenn man etwas vergleichen will, was nicht direkt aus einem Befehl kommt — etwa zwei Strings oder eine Zahl —, braucht man ein Test-Konstrukt. Davon gibt es drei Varianten, die sich in Verbreitung und Mächtigkeit unterscheiden.

Alle drei liefern einen Exit-Code, kein “Boolean”. [ -f datei ] ist also ein Befehl, der 0 zurückgibt, wenn die Datei existiert — und 1, wenn nicht.

test -f /etc/hosts
[ -f /etc/hosts ]
[[ -f /etc/hosts ]]

Der wichtigste Unterschied: [[ ]] ist ein Sprachkonstrukt, kein Befehl. Dadurch macht Bash innerhalb von [[ ]] kein Word-Splitting und kein Glob-Expanding auf nicht-quotierte Variablen. Das macht den Code robuster — und gleichzeitig erlaubt [[ ]] Features, die mit [ ] gar nicht gehen: Glob-Match mit ==, Regex mit =~, sowie && und || direkt im Ausdruck.

In neuen Bash-Skripten gilt: [[ ]] ist die Standardwahl. [ ] braucht man, wenn das Skript POSIX-portabel sein soll (z. B. unter dash als /bin/sh).

String-Vergleiche

Strings vergleicht man mit =, !=, <, > sowie den unären Tests -z (zero, leer) und -n (non-zero, nicht leer). Innerhalb von [[ ]] ist zusätzlich == erlaubt — und übernimmt die spannende Doppelrolle als Glob-Match.

name="Anna"
if [[ "$name" = "Anna" ]]; then
    echo "Hallo, Anna"
fi

if [[ -z "$leer" ]]; then
    echo "Variable ist leer oder ungesetzt"
fi

Der Block zeigt zwei Standard-Tests: Gleichheit per = und Leertest per -z. Beachte die doppelten Anführungszeichen — sie sind in [[ ]] nicht zwingend, schaden aber nie und sind in [ ] Pflicht.

datei="bericht.pdf"
if [[ "$datei" == *.pdf ]]; then
    echo "Es ist ein PDF"
fi

Im rechten Operanden eines == darf in [[ ]] ein Glob-Pattern stehen. Wichtig: Das Muster steht ohne Quotes, sonst wird es als wörtlicher String interpretiert. "$datei" == "*.pdf" wäre exakt der String “*.pdf” — hier nicht gewollt.

eingabe="Version 12.4"
if [[ "$eingabe" =~ ^Version\ ([0-9]+)\.([0-9]+)$ ]]; then
    echo "Major: ${BASH_REMATCH[1]}, Minor: ${BASH_REMATCH[2]}"
fi

=~ matcht den linken Operanden gegen einen erweiterten regulären Ausdruck. Capture-Gruppen landen im Array BASH_REMATCH: Index 0 ist der Gesamttreffer, 1, 2, … sind die Gruppen.

Numerische Vergleiche

Für Zahlen gelten eigene Operatoren, weil < und > in den Test-Konstrukten lexikografisch arbeiten und damit z. B. "10" < "9" als wahr werten würden.

anzahl=12
if [[ "$anzahl" -gt 10 ]]; then
    echo "Mehr als zehn"
fi

Mehr als zehn

Alternativ gibt es das arithmetische Konstrukt (( )), das mit normalen mathematischen Operatoren arbeitet — <, >, ==, !=. Innerhalb von (( )) braucht es keine $ vor Variablennamen:

if (( anzahl > 10 )); then
    echo "Mehr als zehn"
fi

(( )) ist die natürlichere Schreibweise für reine Zahl-Logik — Details und Rechen-Tricks stehen im Artikel zur Arithmetik in Bash.

Datei-Tests

Datei-Tests prüfen Existenz, Typ und Eigenschaften von Dateien und Verzeichnissen. Sie funktionieren in [ ] und [[ ]] gleich.

pfad="/etc/hosts"

if [[ -e "$pfad" ]]; then
    echo "$pfad existiert"
fi

if [[ -f "$pfad" && -r "$pfad" ]]; then
    echo "$pfad ist eine lesbare reguläre Datei"
fi

Der erste Test fragt nur nach Existenz — egal ob Datei, Verzeichnis oder Symlink. Der zweite ist strenger: er verlangt eine reguläre Datei und Leserecht. Beachte das && direkt im [[ ]] — das ist nur dort erlaubt.

if [[ -L "$pfad" ]]; then
    echo "$pfad ist ein Symlink"
elif [[ -d "$pfad" ]]; then
    echo "$pfad ist ein Verzeichnis"
elif [[ -f "$pfad" ]]; then
    echo "$pfad ist eine reguläre Datei"
fi

-L testet auf den Symlink selbst, ohne ihm zu folgen. -f und -d folgen dagegen dem Link — ein Symlink auf ein Verzeichnis ist mit -d wahr. Wenn man explizit den Link-Typ braucht, muss -L zuerst geprüft werden.

Bedingungen kombinieren

Innerhalb von [[ ]] kombiniert man Teilbedingungen mit den Bash-Operatoren && (UND) und || (ODER). Beide arbeiten kurzschließend: bei A && B wird B nur dann ausgewertet, wenn A wahr ist; bei A || B nur, wenn A falsch ist.

if [[ -f "$pfad" && -s "$pfad" ]]; then
    echo "Datei existiert und ist nicht leer"
fi

if [[ "$mode" = "dev" || "$mode" = "test" ]]; then
    echo "Nicht-produktive Umgebung"
fi

Außerhalb von Tests sind && und || Befehlsverkettungen: cmd1 && cmd2 führt cmd2 nur aus, wenn cmd1 mit 0 endet; cmd1 || cmd2 umgekehrt. Das ist das Bash-Idiom schlechthin.

mkdir -p build && cp -r src/* build/
command -v jq >/dev/null || { echo "jq fehlt"; exit 1; }

Die erste Zeile baut das Verzeichnis und kopiert nur, wenn mkdir erfolgreich war. Die zweite prüft, ob jq installiert ist — falls nicht, wird in einer Gruppe { ...; } eine Fehlermeldung gedruckt und das Skript beendet.

Befehl direkt als Bedingung

Eines der wichtigsten Bash-Idiome ist, den Befehl selbst in das if zu schreiben, statt seine Ausgabe in einen Test zu stecken.

if [ "$(grep ERROR log.txt)" != "" ]; then
    echo "Fehler gefunden"
fi

if grep -q ERROR log.txt; then
    echo "Fehler gefunden"
fi

Die zweite Variante ist kürzer, schneller (kein Subshell-Spawn, kein String-Vergleich) und drückt klarer die Absicht aus: “wenn grep fündig wird”. -q (quiet) unterdrückt zusätzlich die Ausgabe.

if command -v docker >/dev/null; then
    echo "Docker ist installiert"
fi

if ping -c 1 -W 1 example.com >/dev/null 2>&1; then
    echo "Netzwerk erreichbar"
fi

command -v X ist die portable Art zu prüfen, ob ein Programm im PATH liegt — sauberer als which. Beim ping nutzen wir >/dev/null 2>&1, um sowohl stdout als auch stderr zu verwerfen, weil uns nur der Exit-Code interessiert.

Praxis-Patterns

Eine Sammlung kleiner Bausteine, die in fast jedem Skript auftauchen — jeweils mit kurzer Erläuterung.

config="/etc/myapp/config.yaml"

if [[ ! -f "$config" ]]; then
    echo "Config fehlt: $config" >&2
    exit 1
fi

Klassischer Vorlauf eines Skripts: Falls die Konfigurationsdatei fehlt, wird auf stderr (>&2) eine Meldung ausgegeben und mit Exit-Code 1 abgebrochen. Das ! negiert den Test.

if [[ -z "${API_TOKEN:-}" ]]; then
    echo "API_TOKEN ist nicht gesetzt" >&2
    exit 1
fi

${API_TOKEN:-} liefert den Inhalt von API_TOKEN oder einen leeren String, wenn die Variable ungesetzt ist. Damit funktioniert der -z-Test auch unter set -u (nounset), das sonst beim Zugriff auf ungesetzte Variablen aussteigt.

for eintrag in /var/log/*; do
    if [[ -d "$eintrag" ]]; then
        echo "DIR : $eintrag"
    elif [[ -f "$eintrag" ]]; then
        echo "FILE: $eintrag"
    fi
done

Die Schleife geht alle Einträge in /var/log durch und sortiert sie nach Typ. -d und -f schließen sich wechselseitig aus, was die Verzweigung sauber lesbar macht.

port="${PORT:-8080}"
echo "Starte auf Port $port"

${PORT:-8080} ist kein Test, sondern eine Parameter-Expansion, ersetzt aber sehr oft ein eigenes if. Mehr zu diesen Mustern steht im Artikel zur String-Manipulation.

if (( score >= 0 && score <= 100 )); then
    echo "Score im erlaubten Bereich"
else
    echo "Score außerhalb 0-100" >&2
fi

Im arithmetischen Kontext lassen sich Bereichschecks natürlich schreiben. Wer das in [[ ]] macht, müsste [[ "$score" -ge 0 && "$score" -le 100 ]] schreiben — funktional gleich, aber sperriger.

Weiterführende Ressourcen

Externe Quellen

• Bash-Manpage: CONDITIONAL EXPRESSIONS — Vollständige Liste aller Test-Operatoren
• GNU Bash-Handbuch: Conditional Constructs — Offizielle Dokumentation zu if, [[ ]], case u. a.
• POSIX: test utility — Was [ ] portabel können muss
• Bash Hackers Wiki: Classic test command — Praktische Übersicht zu [ ] und [[ ]]
• ShellCheck — Statische Analyse, fängt fast alle hier beschriebenen Fallen automatisch

Verwandte Artikel

• Script-Grundlagen — Shebang, set -euo pipefail, robuste Skripte
• Variablen — Shell- und Umgebungsvariablen, Quoting, Expansion
• Schleifen — for, while, until und ihre Stolperfallen
• case-Anweisung — Pattern-Matching als Alternative zu vielen elif
• Funktionen — Wiederverwendbare Logik mit Rückgabewerten und Argumenten