Funktionen

Was Bash-Funktionen sind

In klassischen Programmiersprachen sind Funktionen Konstrukte mit eigenen Parametern, Rückgabetypen und einem isolierten Scope. In Bash ist das anders: Eine Funktion ist im Grunde ein Alias für eine Sequenz von Befehlen. Du gibst ihr einen Namen, hinterlegst einen Block und rufst sie genauso auf wie ls oder grep — ohne Klammern, mit Argumenten dahinter.

Die Shell parsiert das Skript einmal von oben nach unten. Bei einer Funktionsdefinition merkt sie sich nur den Namen und den Rumpf; ausgefuehrt wird nichts. Erst beim Aufruf wird der Rumpf in der aktuellen Shell-Umgebung abgearbeitet — kein neuer Prozess, kein neuer Interpreter, keine Argumentkonvertierung.

Diese Schlichtheit ist Stärke und Falle zugleich: Funktionen lassen sich extrem schnell zusammenstecken, können aber unbemerkt globale Variablen überschreiben oder Exit-Codes verschlucken.

Definition

Bash kennt zwei Schreibweisen für Funktionsdefinitionen. Beide sind funktional äquivalent, aber nicht beide sind portabel.

gruss() {
    echo "Hallo Welt"
}

function gruss {
    echo "Hallo Welt"
}

Die erste Form mit den Klammern ist POSIX-konform und läuft in jeder Bourne-kompatiblen Shell — Bash, Dash, Zsh, Ksh. Die zweite Form mit dem Schlüsselwort function funktioniert in Bash und Zsh, aber nicht in Dash. Da /bin/sh auf vielen Systemen ein Symlink auf Dash ist, ist die erste Variante die sichere Wahl.

Aufgerufen wird die Funktion wie ein Befehl — ohne Klammern:

gruss

Hallo Welt

Wichtig: Die Funktion muss vor dem Aufruf definiert sein. Die Shell parsiert das Skript sequentiell und kennt eine Funktion erst, nachdem sie auf die Definition gestossen ist. Das ist ein typischer Anfängerfehler — Funktionen am Ende des Skripts zu definieren und sie weiter oben aufzurufen.

Parameter

Funktionsargumente werden über dieselben Positionsparameter angesprochen wie Skript-Argumente: $1, $2, $3 und so weiter. Innerhalb der Funktion überschreiben sie die Skript-Argumente lokal — nach dem Funktionsende sind die alten Werte wieder gueltig.

addiere() {
    echo "Erstes Argument: $1"
    echo "Zweites Argument: $2"
    echo "Anzahl Argumente: $#"
    echo "Alle Argumente: $@"
}
addiere 5 7

Erstes Argument: 5
Zweites Argument: 7
Anzahl Argumente: 2
Alle Argumente: 5 7

Die wichtigsten Spezialvariablen innerhalb einer Funktion:

Eine Detail-Falle: $0 zeigt nicht den Funktionsnamen, sondern weiterhin den Skriptnamen. Wer den Funktionsnamen braucht — etwa für Logging — verwendet $FUNCNAME. Eine ausführliche Behandlung der Positionsparameter findest du im Artikel zu Parametern.

Rückgabewerte — drei Wege

Bash kennt keinen Rückgabewert im Sinne anderer Sprachen. Stattdessen gibt es drei pragmatische Wege, ein Ergebnis aus einer Funktion herauszuholen — jeder mit eigenen Vor- und Nachteilen.

Weg 1: return N als Exit-Code

Mit return setzt du den Exit-Code der Funktion. Der Wert muss eine ganze Zahl zwischen 0 und 255 sein. Konvention: 0 bedeutet Erfolg, alles andere ist ein Fehler.

ist_gerade() {
    if (( $1 % 2 == 0 )); then
        return 0
    else
        return 1
    fi
}

if ist_gerade 4; then
    echo "Vier ist gerade"
fi

Vier ist gerade

Der Exit-Code steht nach dem Aufruf in $? zur Verfügung. return ist nur für Status-Informationen geeignet — niemals für Werte wie eine berechnete Summe oder einen Dateinamen.

Weg 2: Output via echo und Capture

Wer einen “echten” Wert zurückgeben will, schreibt ihn auf stdout und fängt ihn beim Aufruf mit Command Substitution ab.

addiere() {
    echo $(( $1 + $2 ))
}

ergebnis=$(addiere 5 7)
echo "Summe: $ergebnis"

Summe: 12

Das ist der idiomatische Weg für beliebige Datentypen — Strings, Zahlen, ganze Listen. Achtung: Innerhalb der Funktion darf dann nichts anderes auf stdout geschrieben werden, sonst landet der “Mist” mit im Ergebnis. Logging gehört in solchen Funktionen auf stderr (siehe Praxis-Patterns).

Weg 3: Globale Variable setzen

Pragmatisch, aber unsauber: Die Funktion schreibt in eine globale Variable, der Aufrufer liest sie aus.

berechne() {
    ERGEBNIS=$(( $1 * $2 ))
}

berechne 6 7
echo "Ergebnis: $ERGEBNIS"

Wird oft eingesetzt, um die Kosten einer Subshell ($(...) startet einen Kindprozess) zu sparen — etwa in performance-kritischen Schleifen mit Tausenden Aufrufen. Bash-Profis nennen das “Output-Variable Pattern”. Sauberer ist es, den Variablennamen als Parameter zu übergeben und mit printf -v zu schreiben, aber das geht über dieses Kapitel hinaus.

Scope und local

Das ist die wichtigste Lektion überhaupt: In Bash sind alle Variablen standardmäßig global. Eine Zuweisung innerhalb einer Funktion verändert dieselbe Variable, die auch außerhalb sichtbar ist — und überschreibt sie eventuell stillschweigend.

zaehler=42

erhoehe() {
    zaehler=$(( zaehler + 1 ))
}

erhoehe
echo "Zaehler ausserhalb: $zaehler"

Zaehler ausserhalb: 43

Manchmal ist das gewollt — meistens nicht. Mit dem Schlüsselwort local machst du eine Variable funktions-lokal: Sie wird beim Funktionseintritt angelegt und beim Funktionsaustritt wieder verworfen. Eine eventuell vorhandene globale Variable gleichen Namens bleibt unangetastet.

zaehler=42

erhoehe() {
    local zaehler=0
    zaehler=$(( zaehler + 1 ))
    echo "Innen: $zaehler"
}

erhoehe
echo "Aussen: $zaehler"

Innen: 1
Aussen: 42

Faustregel: Jede Variable, die du innerhalb einer Funktion zuweist, sollte mit local deklariert sein — es sei denn, du willst bewusst eine globale Variable verändern. Diese eine Disziplin verhindert die meisten schwer auffindbaren Bugs in Shell-Skripten.

local ist übrigens ein Bash/Ksh/Zsh-Feature und nicht POSIX. In striktem POSIX-Skripting (#!/bin/sh mit Dash) gibt es das Schlüsselwort nicht.

Funktionen exportieren

Funktionen leben standardmäßig nur in der Shell, in der sie definiert wurden. Startest du aus dieser Shell heraus eine Subshell — etwa mit bash -c "..." oder durch Command Substitution — kennt diese die Funktion nicht.

Mit export -f machst du eine Funktion für Subshells verfügbar:

gruss() {
    echo "Hallo aus exportierter Funktion"
}

export -f gruss
bash -c 'gruss'

Klassische Falle: export -f funktioniert nur für Bash-Subshells, nicht für Sub-Skripte, die mit einem eigenen Shebang gestartet werden. Wenn du ./anderes-skript.sh aufrufst, wird ein neuer Bash-Prozess gestartet, der seine eigene Initialisierung durchlaeuft — die exportierte Funktion ist dort meist nicht sichtbar (sie kommt zwar als Umgebungsvariable mit, wird aber nur von Bash-Subshells automatisch importiert).

Wenn du Funktionen wirklich projektweit teilen willst, ist die saubere Lösung, sie in eine separate Datei zu legen und mit source datei.sh (oder . datei.sh) in jedes Skript einzubinden.

Praxis-Patterns

Ein paar Bausteine, die in fast jedem groesseren Shell-Skript wiederkehren.

Helper-Funktion für Logging

log() {
    echo "[$(date +%T)] $*" >&2
}

log "Skript gestartet"
log "Verarbeite Datei: input.csv"

Wichtig ist hier das >&2 — die Ausgabe geht auf stderr. Damit verschmutzt das Logging nicht den Datenstrom auf stdout, der eventuell weiterverarbeitet wird. $* fängt alle übergebenen Argumente als einen String. So kannst du log "Hallo Welt" aufrufen, ohne die Argumente zählen zu müssen.

Wrapper mit Rückgabewert

ist_aktiv() {
    pgrep -f "$1" > /dev/null
}

if ist_aktiv "nginx"; then
    echo "nginx laeuft"
else
    echo "nginx ist nicht aktiv"
fi

Die Funktion nutzt den Exit-Code von pgrep direkt — ohne expliziten return. Das ist idiomatisches Bash: Der Exit-Code des letzten Befehls in der Funktion ist automatisch der Exit-Code der Funktion. Die Umleitung > /dev/null unterdrueckt die Ausgabe, weil hier nur das Ergebnis interessiert.

Stdout-Funktion mit Default

get_user() {
    echo "${USER:-anonymous}"
}

aktueller=$(get_user)
echo "Eingeloggt als: $aktueller"

Die Konstruktion ${USER:-anonymous} liefert den Wert von USER, falls gesetzt — sonst den Fallback anonymous. Eine kompakte Methode, um robuste Funktionen zu schreiben, die nicht auf ein leeres Environment hereinfallen.

Mit local und Default-Parametern

begruesse() {
    local name="${1:-Welt}"
    echo "Hallo, $name"
}

begruesse
begruesse "Michael"

Hallo, Welt
Hallo, Michael

Hier kombiniert sich alles: local schuetzt den Scope, ${1:-Welt} liefert einen Default, wenn kein Argument übergeben wird. Das ist die typische Form einer wiederverwendbaren Funktion.

Rekursion

fakultaet() {
    local n=$1
    if (( n <= 1 )); then
        echo 1
    else
        local rest=$(fakultaet $(( n - 1 )))
        echo $(( n * rest ))
    fi
}

fakultaet 5

120

Bash unterstuetzt Rekursion — aber jeder rekursive Aufruf via $(...) startet eine Subshell, was teuer ist. Für mathematische Berechnungen bist du mit bc, awk oder einem richtigen Skriptinterpreter besser bedient. Rekursion in Bash ist eher für Verzeichnis-Traversierungen oder Konfigurations-Resolution sinnvoll.

Weiterfuehrende Ressourcen

Externe Quellen

• Bash-Manpage: Functions (man7.org) — Offizielle Referenz zu Funktionsdefinitionen
• GNU Bash-Handbuch: Shell Functions — Vollstaendige Dokumentation mit Beispielen
• BashFAQ: Functions — Praxiserprobte Antworten zu Scope, Rückgabewerten und Export
• Greg’s Wiki: Bash Pitfalls — Sammlung typischer Fehler, viele rund um Funktionen
• Advanced Bash-Scripting Guide: Functions — Tiefer Einblick mit zahlreichen Beispielen

Verwandte Artikel

• Parameter und Argumente — Positionsparameter und Argument-Handling im Detail
• Exit-Codes — Wie Bash Erfolg und Fehler signalisiert
• Fehlerbehandlung — set -e, trap und robuste Skripte
• Schleifen — for, while und until in Skripten
• Skript-Grundlagen — Shebang, Ausführungsrechte und Aufbau eines Skripts