case

Was case macht

case vergleicht eine Variable oder einen Ausdruck gegen eine Liste von Mustern und führt den Block aus, der zum ersten passenden Muster gehört. Anders als ein klassischer switch in C oder Java arbeitet Bash dabei nicht mit festen Werten, sondern mit Glob-Pattern — derselben Muster-Sprache, die auch beim Dateinamen-Matching in der Shell zum Einsatz kommt.

Der typische Anwendungsfall: Du hast eine Variable, die mehrere mögliche Werte annehmen kann, und willst pro Wert unterschiedliche Aktionen ausführen. Mit if/elif sieht das schnell unübersichtlich aus:

if [ "$mode" = "start" ]; then
    starte_dienst
elif [ "$mode" = "stop" ]; then
    stoppe_dienst
elif [ "$mode" = "restart" ]; then
    stoppe_dienst
    starte_dienst
else
    echo "Unbekannter Modus: $mode"
fi

Mit case wird daraus eine flache Liste — jeder Pattern-Block ist auf einen Blick erkennbar, und neue Optionen lassen sich ohne Verschachtelung einfügen. case ist zudem ein Bash-Builtin, das beim Pattern-Matching meist schneller ist als eine Folge externer [-Aufrufe.

Syntax

Die Grundform ist immer gleich: ein Wert wird gegen eine Liste von Pattern-Blöcken geprüft, jeder Block endet mit ;;, das Ganze wird mit esac (case rückwärts) abgeschlossen.

case $variable in
    PATTERN1)
        # Befehle für Pattern 1
        ;;
    PATTERN2)
        # Befehle für Pattern 2
        ;;
    *)
        # Default-Fall
        ;;
esac

Konkretes Beispiel mit einer Mode-Variable:

mode="start"

case "$mode" in
    start)
        echo "Dienst wird gestartet"
        ;;
    stop)
        echo "Dienst wird gestoppt"
        ;;
    restart)
        echo "Dienst wird neu gestartet"
        ;;
    *)
        echo "Unbekannter Modus: $mode"
        ;;
esac

Die wichtigsten Bestandteile im Detail:

case stoppt beim ersten passenden Pattern — alles danach wird ignoriert. Die Reihenfolge der Pattern ist deshalb wichtig: spezifische Pattern gehören vor allgemeine, der Default *) immer ans Ende.

Glob-Pattern in case

Pattern in case sind keine regulären Ausdrücke, sondern dieselben Glob-Muster, die die Shell auch beim Datei-Matching verwendet. Das ist ein häufiger Stolperstein für Programmierer, die von Sprachen mit Regex-Switches kommen.

Beispiel mit Datei-Endungen:

datei="bericht.pdf"

case "$datei" in
    *.txt)
        echo "Textdatei"
        ;;
    *.pdf)
        echo "PDF-Dokument"
        ;;
    *.[jp][pn]g)
        echo "Bild (jpg oder png)"
        ;;
esac

Wer Regex-artige Pattern braucht — etwa mehrstellige Quantoren oder Alternativen — sollte stattdessen [[ $var =~ regex ]] verwenden. case deckt aber 90 Prozent der typischen Fälle ab.

Multi-Pattern mit |

Mehrere Pattern lassen sich in einem Block mit dem Pipe-Zeichen | kombinieren. Das ist die klassische Lösung für Eingaben, die in mehreren Schreibweisen akzeptiert werden sollen — Ja/Nein-Prompts sind das Standardbeispiel.

read -p "Wirklich löschen? [j/N] " antwort

case "$antwort" in
    j|J|ja|JA|yes|y|Y)
        echo "Lösche..."
        ;;
    n|N|nein|NEIN|no|"")
        echo "Abgebrochen"
        ;;
    *)
        echo "Bitte j oder n eingeben"
        ;;
esac

Der |-Operator hat innerhalb von case nichts mit der Pipe der Shell zu tun — hier bedeutet er logisches ODER zwischen Pattern. Auch leere Eingaben lassen sich mit "" matchen, was den Default-Wert eines Prompts abbildet (z. B. wenn der Benutzer einfach Enter drückt).

Fall-Through mit ;& und ;;&

Standardmässig endet case nach dem ersten Match — egal, ob nachfolgende Pattern auch passen würden. Ab Bash 4 gibt es zwei Terminator-Varianten, die dieses Verhalten ändern und Fall-Through erlauben.

Beispiel für ;;& — eine Datei wird mehrfach klassifiziert:

datei="archiv.tar.gz"

case "$datei" in
    *.gz)
        echo "Gzip-komprimiert"
        ;;&
    *.tar.gz)
        echo "Tar-Archiv"
        ;;&
    *.*)
        echo "Hat eine Endung"
        ;;
esac

Gzip-komprimiert
Tar-Archiv
Hat eine Endung

Mit ;& springst du dagegen direkt in den nächsten Block, unabhängig davon, ob dessen Pattern matcht. Das ist nützlich für gestaffelte Defaults oder gemeinsam genutzte Cleanup-Schritte.

Praxis-Patterns

Im Alltag taucht case vor allem in fünf Konstellationen auf. Jedes Beispiel ist eigenständig nutzbar und zeigt eine typische Shell-Aufgabe.

Argument-Parsing für CLI-Skripte

Skripte mit mehreren Subkommandos (start, stop, status) verwenden case als zentrale Verteilung. Der erste positionelle Parameter $1 ist der Subkommando-Name, alles weitere wird an Funktionen delegiert.

case "$1" in
    start)
        starte_app
        ;;
    stop)
        stoppe_app
        ;;
    status)
        zeige_status
        ;;
    -h|--help)
        zeige_hilfe
        ;;
    *)
        echo "Verwendung: $0 {start|stop|status}"
        exit 1
        ;;
esac

Der *)-Default fängt unbekannte Aufrufe ab und gibt eine Usage-Meldung aus. exit 1 signalisiert dem Aufrufer einen Fehler — wichtig für Skripte, die in Pipelines oder CI-Systemen laufen.

Datei-Endungs-basierte Aktion

Statt mit if-Kaskaden auf Endungen zu prüfen, sortierst du mit case direkt nach Suffix. Das ist die typische Lösung für Konverter-Skripte oder Build-Helfer.

for datei in "$@"; do
    case "$datei" in
        *.md)
            pandoc "$datei" -o "${datei%.md}.html"
            ;;
        *.scss)
            sass "$datei" "${datei%.scss}.css"
            ;;
        *.ts)
            tsc "$datei"
            ;;
        *)
            echo "Übersprungen: $datei"
            ;;
    esac
done

Die Parameter-Expansion ${datei%.md} schneidet die Endung ab — typisches Bash-Pattern in Kombination mit case.

Yes/No-Prompt

Ein klassisches interaktives Muster — alle gängigen Schreibweisen werden akzeptiert, der Rest landet in einem Retry-Default.

read -p "Fortfahren? [j/N] " a
case "$a" in
    [jJ]|[jJ][aA]|[yY]|[yY][eE][sS])
        echo "weiter"
        ;;
    *)
        echo "abgebrochen"
        exit 0
        ;;
esac

[jJ] matcht ein einzelnes j oder J, [jJ][aA] matcht ja, Ja, jA, JA. So sparst du dir die Aufzählung aller Kombinationen mit |.

Default-Fallback mit *)

Der *)-Block ist der Joker — er matcht alles, was vorher nicht gegriffen hat. Pflicht für robuste Skripte, sonst geht ein unerwarteter Wert kommentarlos durch.

case "$ENV" in
    dev|development)
        LOG_LEVEL=debug
        ;;
    prod|production)
        LOG_LEVEL=warn
        ;;
    *)
        echo "Warnung: unbekannte Umgebung '$ENV', setze LOG_LEVEL=info"
        LOG_LEVEL=info
        ;;
esac

Hier wird der Default nicht zum Fehlerausstieg, sondern zur sicheren Fallback-Konfiguration. Beide Varianten sind legitim — abhängig davon, ob ein unbekannter Wert kritisch ist oder nicht.

OS-Detection mit case "$(uname)"

Skripte, die auf Linux und macOS laufen sollen, müssen oft unterscheiden, welcher Kernel darunter liegt. uname liefert den Namen, case verzweigt darauf.

case "$(uname -s)" in
    Linux*)
        OPEN=xdg-open
        ;;
    Darwin*)
        OPEN=open
        ;;
    CYGWIN*|MINGW*|MSYS*)
        OPEN=start
        ;;
    *)
        echo "Unbekanntes OS: $(uname -s)"
        exit 1
        ;;
esac

$OPEN "$1"

Die Pattern enden auf *, weil uname Varianten wie Linux oder Linux-x86_64 ausgeben kann. Multi-Pattern fängt zusätzlich alle Windows-Bash-Varianten in einem Block ab.

Weiterführende Ressourcen

Externe Quellen

• Bash Reference Manual: Conditional Constructs — formale Definition von case, inklusive Fall-Through-Terminatoren
• Bash-Manpage (man7.org) — Compound-Commands-Abschnitt mit case-Syntax
• Bash Hackers Wiki: case — praxisnahe Beispiele und Edge Cases
• ShellCheck — statische Analyse, warnt vor unsicheren case-Pattern

Verwandte Artikel

• Bedingungen — if, elif, Test-Ausdrücke und wann case die bessere Wahl ist
• Schleifen — for und while als Ergänzung zu Verzweigungen
• Parameter — $1, $@ und Argument-Handling für CLI-Skripte
• Globbing — die Pattern-Sprache hinter case
• Skript-Grundlagen — Shebang, Ausführbarkeit und Skript-Aufbau