0Pricing
DevOps Bootcamp · Lektion

Funktionen in Bash-Skripten

Strukturieren Sie Ihren Code mit Funktionen, fördern Sie die Wiederverwendbarkeit und machen Sie Ihre Skripte übersichtlicher und leichter wartbar.

Funktionen in Bash-Skripten ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was sind Bash-Funktionen?

Beim Scripting mit Bash ist eine Funktion ein Codeblock, der eine bestimmte Aufgabe ausführt. Stellen Sie sie sich als kleines Skript innerhalb Ihres Hauptskripts vor.

Funktionen helfen Ihnen dabei:

  • Code wiederzuverwenden: Eine Logik einmal schreiben und mehrfach aufrufen.
  • Skripte zu strukturieren: Komplexe Aufgaben in kleinere, überschaubare Einheiten aufteilen.
  • Die Lesbarkeit zu verbessern: Ihr Skript verständlicher und leichter zu warten zu machen.

Eine einfache Funktion definieren

In Bash gibt es zwei gängige Möglichkeiten, eine Funktion zu definieren. Beide führen zum gleichen Ergebnis. Die erste Syntax ist am weitesten verbreitet.

Führen Sie dieses Beispiel aus. Es definiert Funktionen, ruft sie aber noch nicht auf!

#!/bin/bash

# Method 1: The most common way
my_first_func () {
  echo "Hello from my_first_func!"
}

# Method 2: Using the 'function' keyword
function my_second_func {
  echo "Hello from my_second_func!"
}

echo "Functions defined, but not called."

Ihre Funktionen aufrufen

Das Definieren einer Funktion führt sie nicht aus. Um den Code innerhalb einer Funktion auszuführen, rufen Sie sie einfach über ihren Namen auf – genau wie jeden anderen Befehl.

Sehen Sie, wie wir my_function nach der Definition aufrufen:

#!/bin/bash

my_function () {
  echo "This message is from inside the function."
}

echo "Script started."
my_function # Call the function here
echo "Script finished."

Lokale Variablen in Funktionen

Standardmäßig sind Variablen, die innerhalb einer Bash-Funktion definiert werden, global. Das bedeutet, dass sie von überall im Skript abgerufen und geändert werden können.

Um unbeabsichtigte Seiteneffekte zu verhindern und Ihre Funktionen voneinander zu isolieren, verwenden Sie das Schlüsselwort local, um eine Variable als lokal zu deklarieren. Lokale Variablen existieren nur innerhalb der jeweiligen Funktion.

#!/bin/bash

global_message="I'm a global message"

my_function () {
  local func_message="I'm a local message"
  global_message="I've been changed by the function!"
  echo "Inside func: $func_message"
  echo "Inside func: $global_message"
}

echo "Before func: $global_message"
my_function
echo "After func: $global_message"
echo "After func: $func_message (This will be empty)"

Argumente an Funktionen übergeben

Sie können Informationen über Argumente an Ihre Funktionen übergeben, genau wie bei regulären Shell-Befehlen. Innerhalb der Funktion werden diese Argumente über spezielle Variablen abgerufen:

  • $1, $2, $3...: Einzelne Argumente
  • $#: Die Gesamtzahl der Argumente
  • $@: Alle Argumente als separate Zeichenketten
#!/bin/bash

greet_user () {
  echo "Hello, $1!"
  echo "You are $2 years old."
  echo "Total arguments received: $#"
  echo "All arguments: $@"
}

echo "Calling greet_user with two arguments:"
greet_user "Alice" 30

echo "\nCalling greet_user with one argument:"
greet_user "Bob"

Exit-Status einer Funktion (Return)

Eine Funktion gibt wie jeder Befehl einen Exit-Status zurück. Üblicherweise bedeutet 0 Erfolg, während jeder Wert ungleich null auf einen Fehler hinweist.

Mit dem Schlüsselwort return legen Sie diesen Exit-Status fest. Anschließend können Sie ihn direkt nach dem Funktionsaufruf über die spezielle Variable $? überprüfen.

#!/bin/bash

check_age () {
  local age=$1
  if [ "$age" -ge 18 ]; then
    return 0 # Success: 18 or older
  else
    return 1 # Failure: under 18
  fi
}

check_age 25
echo "Exit status for 25: $?"

check_age 16
echo "Exit status for 16: $?"

if check_age 20; then
  echo "User is an adult."
else
  echo "User is a minor."
fi

Ausgabe einer Funktion erfassen

Während return einen Exit-Status zurückgibt, sollte eine Funktion den gewünschten „Wert“ mit echo in die Standardausgabe schreiben, wenn dieser in einer Variable gespeichert werden soll.

Anschließend erfassen Sie diese Ausgabe mit einer Befehlssubstitution, indem Sie den Funktionsaufruf in $(...) einschließen.

#!/bin/bash

get_full_name () {
  local first_name=$1
  local last_name=$2
  echo "$first_name $last_name" # Echo the full name
}

name="$(get_full_name "John" "Doe")"

echo "Full name captured: $name"

calculate_area () {
  local length=$1
  local width=$2
  echo $((length * width))
}

area=$(calculate_area 10 5)
echo "Calculated area: $area"

Praxisbeispiel: Ein Logger

Hier ist ein praktisches Beispiel für eine wiederverwendbare Funktion: ein einfacher Logger. Diese Funktion kann im gesamten Skript aufgerufen werden, um Nachrichten mit einem Zeitstempel auszugeben. Das erleichtert das Debugging und die Nachverfolgung.

#!/bin/bash

log_message () {
  local timestamp=$(date +"%Y-%m-%d %H:%M:%S")
  local message="$1"
  echo "[$timestamp] $message"
}

log_message "Script execution started."
sleep 1 # Simulate some work
log_message "Processing user data..."
sleep 1
log_message "Operation completed successfully."

Bewährte Vorgehensweisen für Funktionen

Beachten Sie die folgenden Tipps, um klare und wartbare Skripte mit Funktionen zu schreiben:

  • Halten Sie es einfach: Jede Funktion sollte eine Aufgabe gut erfüllen.
  • Aussagekräftige Namen: Verwenden Sie beschreibende Namen wie validate_input oder create_backup.
  • local verwenden: Verwenden Sie für Variablen innerhalb von Funktionen immer local, um Konflikte zu vermeiden.
  • Kommentare hinzufügen: Erklären Sie, was Ihre Funktion tut, welche Argumente sie erwartet und was sie zurückgibt.
  • Eingaben validieren: Wenn eine Funktion bestimmte Argumente erwartet, überprüfen Sie diese.

Argumente einer Funktion überprüfen

Testen Sie Ihr Verständnis dafür, wie Argumente an Bash-Funktionen übergeben und innerhalb dieser abgerufen werden.

Funktionen: Zusammenfassung und nächste Schritte

Sehr gut! Sie beherrschen jetzt Bash-Funktionen.

Sie haben Folgendes behandelt:

  • Funktionen definieren und aufrufen.
  • local für den Variablenbereich verwenden.
  • Argumente mit $1, $# und $@ übergeben.
  • Den Exit-Status mit return festlegen.
  • Ausgaben mit echo und Befehlssubstitution erfassen.

Funktionen sind entscheidend für das Schreiben modularer, wiederverwendbarer und wartbarer Bash-Skripte. Üben Sie weiter, damit Ihre Skripte leistungsfähiger und übersichtlicher werden!

Häufig gestellte Fragen

Ist die Lektion „Funktionen in Bash-Skripten“ kostenlos?

Ja — der vollständige Text von „Funktionen in Bash-Skripten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Funktionen in Bash-Skripten“?

Strukturieren Sie Ihren Code mit Funktionen, fördern Sie die Wiederverwendbarkeit und machen Sie Ihre Skripte übersichtlicher und leichter wartbar. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Funktionen in Bash-Skripten“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Schleifenkonstrukte (for, while)
  2. Funktionen in Bash-Skripten
  3. Skriptargumente und Optionen ($@, $#, getopts)
  4. Die case-Anweisung und Pattern Matching
← Zurück zu DevOps Bootcamp