Funktionen in Bash

Funktionen in Bash fassen mehrere Befehle zu einem wiederverwendbaren Block zusammen. Sie machen Skripte übersichtlicher und vermeiden redundanten Code.

Syntax einer Bash-Funktion

Eine Funktion besteht aus einem Namen und einem Codeblock in geschweiften Klammern:

funktionsname() {
  befehle
}

• funktionsname - Der Name, unter dem die Funktion aufgerufen wird.
• befehle - Ein oder mehrere Befehle, die beim Aufruf ausgeführt werden.

Es gibt auch eine alternative Schreibweise mit dem Schlüsselwort function:

function funktionsname {
  befehle
}

Beide Varianten funktionieren identisch. Die erste Form ohne function ist verbreiteter und kompatibler mit anderen Shells.

Eine Funktion definieren und aufrufen

Die Funktionsdefinition muss vor dem ersten Aufruf stehen. Der Aufruf erfolgt durch Angabe des Funktionsnamens:

#!/bin/bash

gruss() {
  echo "Hallo Welt"
}

gruss

Dieses Skript gibt Hallo Welt aus. Die Funktion gruss kannst du beliebig oft aufrufen.

Parameter an Funktionen übergeben

Parameter werden beim Aufruf durch Leerzeichen getrennt hinter den Funktionsnamen geschrieben. Innerhalb der Funktion greifst du mit $1, $2, $3 usw. auf die Werte zu:

#!/bin/bash

begruessung() {
  echo "Hallo $1, willkommen bei $2"
}

begruessung "Anna" "Linux"

Ausgabe:

Hallo Anna, willkommen bei Linux

Weitere nützliche Variablen für Parameter:

• $# - Anzahl der übergebenen Parameter
• $@ - Alle Parameter als einzelne Strings
• $* - Alle Parameter als ein String

Setze Argumente mit Leerzeichen in Anführungszeichen, damit sie als ein Parameter erkannt werden:

begruessung "Max Mustermann" "der Kommandozeile"

Lokale und globale Variablen

Variablen in Bash sind standardmäßig global. Das bedeutet, eine Variable innerhalb einer Funktion ist auch außerhalb sichtbar. Mit dem Schlüsselwort local beschränkst du eine Variable auf die Funktion:

#!/bin/bash

name="global"

aendere_name() {
  local name="lokal"
  echo "In der Funktion: $name"
}

echo "Vor dem Aufruf: $name"
aendere_name
echo "Nach dem Aufruf: $name"

Ausgabe:

Vor dem Aufruf: global
In der Funktion: lokal
Nach dem Aufruf: global

Ohne local hätte die Funktion die globale Variable überschrieben. Verwende local für Variablen, die nur innerhalb der Funktion relevant sind.

Rückgabewerte

Bash-Funktionen geben keinen Wert im klassischen Sinne zurück. Stattdessen liefert return einen Exit-Status zwischen 0 und 255. Der Wert 0 bedeutet Erfolg, alle anderen Werte signalisieren einen Fehler:

#!/bin/bash

pruefe_datei() {
  if [[ -f "$1" ]]; then
    return 0
  else
    return 1
  fi
}

pruefe_datei "/etc/passwd"
echo "Exit-Status: $?"

Der Exit-Status steht in der Variablen $? und ist nur direkt nach dem Funktionsaufruf verfügbar.

Werte aus Funktionen auslesen

Um tatsächlich Daten aus einer Funktion zu erhalten, gibt es zwei Methoden.

Methode 1: Ausgabe mit echo und Kommandosubstitution

Die Funktion gibt den Wert mit echo aus. Der Aufruf erfolgt in $():

#!/bin/bash

verdopple() {
  local ergebnis=$(( $1 * 2 ))
  echo $ergebnis
}

resultat=$(verdopple 21)
echo "Das Ergebnis ist $resultat"

Ausgabe:

Das Ergebnis ist 42

Methode 2: Globale Variable setzen

Die Funktion schreibt das Ergebnis in eine globale Variable:

#!/bin/bash

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

verdopple 21
echo "Das Ergebnis ist $ERGEBNIS"

Die erste Methode mit Kommandosubstitution ist sauberer, da sie keine globalen Variablen benötigt.

Einzeilige Funktionen

Kurze Funktionen lassen sich in einer Zeile schreiben. Das Semikolon vor der schließenden Klammer ist dabei erforderlich:

gruss() { echo "Hallo $1"; }

Diese Schreibweise eignet sich für einfache Funktionen, die nur einen Befehl ausführen.

Funktionen in der Shell definieren

Funktionen müssen nicht in einem Skript stehen. Du kannst sie direkt in der Shell definieren oder in deine ~/.bashrc eintragen:

mkcd() { mkdir -p "$1" && cd "$1"; }

Diese Funktion erstellt ein Verzeichnis und wechselt direkt hinein. Nach dem Hinzufügen zur ~/.bashrc steht sie in jeder neuen Shell zur Verfügung.

Zusammenfassung

Bash-Funktionen strukturieren Skripte und vermeiden Wiederholungen. Parameter werden mit $1, $2 usw. verarbeitet, lokale Variablen mit local deklariert. Für Rückgabewerte nutzt du entweder echo mit Kommandosubstitution oder globale Variablen.