Shell-Funktionen und Unterprogramme

Einführung

In diesem Lab werden wir uns mit Shell-Funktionen unter Linux beschäftigen. Shell-Funktionen sind wiederverwendbare Codeblöcke, die spezifische Aufgaben ausführen und unsere Skripte dadurch organisierter und effizienter machen. Wir werden lernen, wie man Funktionen in Shell-Skripten erstellt, aufruft und mit Parametern nutzt. Dieses Lab ist für Anfänger konzipiert, daher gehen wir Schritt für Schritt vor und erklären jedes Konzept ausführlich.

Erstellen Ihrer ersten Shell-Funktion

Beginnen wir mit der Erstellung einer einfachen Shell-Funktion. Shell-Funktionen sind wie Mini-Skripte innerhalb eines größeren Skripts, die es Ihnen ermöglichen, Befehle zu gruppieren, die eine bestimmte Aufgabe erfüllen.

Zuerst müssen wir eine neue Datei erstellen. Öffnen Sie Ihr Terminal und geben Sie folgendes ein:

cd ~/project
touch functions.sh

Dieser Befehl wechselt in das Verzeichnis project und erstellt eine neue Datei namens functions.sh. Diese Datei wird unsere Shell-Funktionen enthalten.

Nun fügen wir unsere erste Funktion hinzu:

#!/bin/bash

## Dies ist eine einfache Funktion
greet() {
  echo "Hello, World!"
}

## Diese Zeile ruft die Funktion auf (führt sie aus)
greet

Lassen Sie uns das Ganze aufschlüsseln:

Die erste Zeile #!/bin/bash wird Shebang genannt. Sie weist das System an, Bash zu verwenden, um dieses Skript zu interpretieren.
Wir definieren unsere Funktion mit greet() { }. Alles zwischen den geschweiften Klammern gehört zur Funktion.
Innerhalb der Funktion haben wir einen einfachen echo-Befehl, der "Hello, World!" ausgibt.
Die letzte Zeile greet ruft unsere Funktion auf.

Jetzt machen wir unser Skript ausführbar und starten es:

chmod +x functions.sh
./functions.sh

Sie sollten folgende Ausgabe sehen:

Hello, World!

Falls Sie diese Ausgabe nicht sehen, prüfen Sie bitte noch einmal genau, ob Sie alles korrekt in die Datei functions.sh eingegeben haben.

Funktionen mit Parametern

Nachdem wir eine Basisfunktion erstellt haben, machen wir sie nun flexibler, indem wir Parameter hinzufügen. Parameter ermöglichen es uns, Informationen an unsere Funktionen zu übergeben.

Öffnen Sie die Datei functions.sh erneut und ersetzen Sie den Inhalt durch den folgenden Code:

#!/bin/bash

## Funktion mit einem Parameter
greet() {
  echo "Hello, $1!"
}

## Funktion mit mehreren Parametern
calculate() {
  echo "The sum of $1 and $2 is $(($1 + $2))"
}

## Funktionen mit Argumenten aufrufen
greet "Alice"
calculate 5 3

Betrachten wir diesen Code genauer:

In der Funktion greet bezieht sich $1 auf das erste Argument, das an die Funktion übergeben wurde.
In der Funktion calculate beziehen sich $1 und $2 auf das erste bzw. zweite Argument.
$(($1 + $2)) führt eine arithmetische Addition der beiden Parameter durch.

Führen Sie das Skript aus:

./functions.sh

Sie sollten sehen:

Hello, Alice!
The sum of 5 and 3 is 8

Wenn diese Ausgabe nicht erscheint, stellen Sie sicher, dass Sie die Änderungen an der Datei korrekt gespeichert haben.

Rückgabewerte von Funktionen

Beim Shell-Scripting geben Funktionen Werte nicht auf die gleiche Weise zurück wie in anderen Programmiersprachen. Stattdessen können sie entweder ein Ergebnis per echo ausgeben, das abgefangen werden kann, oder sie können eine globale Variable ändern. Wir werden beide Methoden untersuchen.

Öffnen Sie functions.sh erneut und aktualisieren Sie den Inhalt mit folgendem Code:

#!/bin/bash

## Funktion, die ein Ergebnis ausgibt
get_square() {
  echo $(($1 * $1))
}

## Funktion, die eine globale Variable ändert
RESULT=0
set_global_result() {
  RESULT=$(($1 * $1))
}

## Das ausgegebene Ergebnis abfangen
square_of_5=$(get_square 5)
echo "The square of 5 is $square_of_5"

## Die Funktion nutzen, um die globale Variable zu ändern
set_global_result 6
echo "The square of 6 is $RESULT"

Lassen Sie uns das analysieren:

Die Funktion get_square verwendet echo, um das Ergebnis auszugeben, welches wir mit der $()-Syntax abfangen.
Die Funktion set_global_result verändert die globale Variable RESULT.
Wir nutzen $(), um die Ausgabe von get_square in einer Variable zu speichern.
Wir rufen set_global_result auf, was RESULT verändert, und geben RESULT anschließend aus.

Speichern Sie die Datei und führen Sie sie aus:

./functions.sh

Sie sollten sehen:

The square of 5 is 25
The square of 6 is 36

Falls die Ausgabe abweicht, prüfen Sie Ihre functions.sh auf Tippfehler.

Den Gültigkeitsbereich von Variablen verstehen

In Shell-Skripten sind Variablen standardmäßig global. Das bedeutet, sie können von überall im Skript aufgerufen werden. Sie können jedoch das Schlüsselwort local verwenden, um Variablen zu erstellen, die nur innerhalb einer Funktion zugänglich sind. Dies nennt man lokalen Gültigkeitsbereich (Local Scope).

Lassen Sie uns functions.sh anpassen, um dieses Konzept zu verdeutlichen.

Aktualisieren Sie den Inhalt mit folgendem Code:

#!/bin/bash

## Globale Variable
GLOBAL_VAR="I'm global"

## Funktion mit einer lokalen Variable
demonstrate_scope() {
  local LOCAL_VAR="I'm local"
  echo "Inside function: GLOBAL_VAR = $GLOBAL_VAR"
  echo "Inside function: LOCAL_VAR = $LOCAL_VAR"
}

## Die Funktion aufrufen
demonstrate_scope

echo "Outside function: GLOBAL_VAR = $GLOBAL_VAR"
echo "Outside function: LOCAL_VAR = $LOCAL_VAR"

Das passiert in diesem Skript:

Wir definieren eine globale Variable GLOBAL_VAR.
Innerhalb der Funktion demonstrate_scope definieren wir eine lokale Variable LOCAL_VAR mit dem Schlüsselwort local.
Wir geben beide Variablen innerhalb der Funktion aus.
Nach dem Funktionsaufruf versuchen wir, beide Variablen erneut außerhalb der Funktion auszugeben.

Speichern Sie die Datei und führen Sie sie aus:

./functions.sh

Sie sollten eine Ausgabe ähnlich dieser sehen:

Inside function: GLOBAL_VAR = I'm global
Inside function: LOCAL_VAR = I'm local
Outside function: GLOBAL_VAR = I'm global
Outside function: LOCAL_VAR =

Beachten Sie, dass LOCAL_VAR leer ist, wenn darauf von außerhalb der Funktion zugegriffen wird. Das liegt daran, dass lokale Variablen nur innerhalb der Funktion existieren, in der sie definiert wurden.

Fortgeschrittene Funktion - ENGLISH_CALC

Nachdem wir die Grundlagen von Shell-Funktionen behandelt haben, erstellen wir nun eine komplexere Funktion namens ENGLISH_CALC. Diese Funktion wird drei Argumente entgegennehmen: zwei Zahlen und eine Operation (plus, minus oder times).

Ersetzen Sie den Inhalt durch den folgenden Code:

#!/bin/bash

ENGLISH_CALC() {
  local num1=$1
  local operation=$2
  local num2=$3
  local result

  case $operation in
    plus)
      result=$((num1 + num2))
      echo "$num1 + $num2 = $result"
      ;;
    minus)
      result=$((num1 - num2))
      echo "$num1 - $num2 = $result"
      ;;
    times)
      result=$((num1 * num2))
      echo "$num1 * $num2 = $result"
      ;;
    *)
      echo "Invalid operation. Please use 'plus', 'minus', or 'times'."
      return 1
      ;;
  esac
}

## Die Funktion testen
ENGLISH_CALC 3 plus 5
ENGLISH_CALC 5 minus 1
ENGLISH_CALC 4 times 6
ENGLISH_CALC 2 divide 2 ## Dies sollte eine Fehlermeldung zeigen

Lassen Sie uns diese Funktion aufschlüsseln:

Wir verwenden local Variablen, um unsere Eingaben und Ergebnisse zu speichern. Dies ist eine gute Praxis, um Konflikte mit globalen Variablen zu vermeiden.
Wir nutzen eine case-Anweisung, um verschiedene Operationen zu handhaben. Dies ähnelt einem Switch-Statement in anderen Sprachen.
Für jede gültige Operation führen wir die Berechnung durch und geben das Ergebnis aus.
Wenn eine ungültige Operation angegeben wird, geben wir eine Fehlermeldung aus und geben 1 zurück (in Shell-Skripten signalisiert ein Rückgabewert ungleich Null einen Fehler).
Am Ende testen wir unsere Funktion mit verschiedenen Eingaben, einschließlich einer ungültigen Operation.

Speichern Sie die Datei und führen Sie sie aus:

./functions.sh

Sie sollten die folgende Ausgabe sehen:

3 + 5 = 8
5 - 1 = 4
4 * 6 = 24
Invalid operation. Please use 'plus', 'minus', or 'times'.

Falls Sie diese Ausgabe nicht sehen, prüfen Sie Ihre functions.sh erneut auf Tippfehler.

Zusammenfassung

In diesem Lab haben wir Shell-Funktionen unter Linux erkundet, angefangen bei den Grundlagen bis hin zu fortgeschritteneren Konzepten. Wir haben gelernt, wie man:

Einfache Funktionen erstellt und aufruft.
Mit Funktionsparametern arbeitet.
Werte aus Funktionen mittels echo und globalen Variablen zurückgibt.
Den Gültigkeitsbereich von Variablen versteht und lokale Variablen einsetzt.
Eine komplexere Funktion erstellt, die arithmetische Operationen verarbeitet.

Shell-Funktionen sind mächtige Werkzeuge, die Ihnen helfen, organisierten, effizienten und wiederverwendbaren Code zu schreiben. Sie ermöglichen es Ihnen, komplexe Skripte in kleinere, handhabbare Teile zu zerlegen, wodurch Ihre Skripte leichter verständlich und wartbar werden.

Durch das Beherrschen von Shell-Funktionen werden Sie in der Lage sein, anspruchsvollere Shell-Skripte zu schreiben und komplexe Aufgaben in einer Linux-Umgebung effektiver zu automatisieren. Denken Sie daran: Übung ist der Schlüssel, um im Shell-Scripting sicher zu werden. Versuchen Sie, die erstellten Funktionen zu modifizieren oder eigene zu entwerfen, um spezifische Probleme in Ihrem Linux-Alltag zu lösen.