Einführung
Beim Schreiben von Skripten müssen Sie häufig denselben Codeblock mehrmals wiederholen. Anstatt diesen Code neu zu schreiben oder zu kopieren und einzufügen, können Sie Funktionen verwenden.
Eine Funktion ist ein benannter Codeblock, der eine bestimmte Aufgabe ausführt. Sie definieren ihn einmal und können ihn anschließend jederzeit aufrufen, wenn Sie ihn benötigen. Dadurch werden Ihre Skripte:
- Modular: Sie lassen sich leichter lesen und verwalten.
- Wiederverwendbar: Einmal schreiben, mehrfach verwenden.
- Wartbar: Wenn Sie die Logik ändern müssen, aktualisieren Sie sie nur an einer Stelle.
Funktionen sind wichtig, weil größere Skripte schwer verständlich werden, wenn der gesamte Code in einem langen Block von oben nach unten steht. Ein Skript in Funktionen aufzuteilen, ist einer der ersten Schritte vom „schnellen Shell-Hack“ hin zu wartbarer Automatisierung.
In diesem Lab lernen Sie die Grundlagen, wie Sie ein Skript mithilfe von Funktionen neu strukturieren. Sie werden:
- Ein einfaches Skript erstellen.
- Eine Funktion namens
greet_userdefinieren. - Die Funktion aufrufen, um sie auszuführen.
- Die Funktion so erweitern, dass sie Parameter (Argumente) akzeptiert.
Die Skriptdatei erstellen
Richten Sie zunächst Ihren Arbeitsbereich ein. Sie erstellen eine Datei namens functions.sh, die Ihren Code aufnehmen wird.
In diesem Stadium ist die Skriptdatei zunächst nur ein Container. Die wichtige Änderung in diesem Lab betrifft nicht die Datei selbst, sondern die Idee, ein Skript in benannte Abschnitte statt in eine einzige lange Abfolge von oben nach unten zu gliedern.
Wechseln Sie zunächst in das Projektverzeichnis und erstellen Sie die Datei:
cd ~/project
touch functions.sh
Öffnen Sie anschließend die Datei im Texteditor, um den standardmäßigen Shebang am Anfang einzufügen:
nano functions.sh
Fügen Sie die folgende Zeile am Anfang der Datei ein:
#!/bin/bash
Speichern Sie die Datei (Ctrl+O, Enter) und beenden Sie den Editor (Ctrl+X).
Machen Sie das Skript schließlich ausführbar, damit Sie es später starten können:
chmod +x functions.sh
Jetzt können Sie mit dem Schreiben des Codes beginnen.
Eine Funktion definieren
Definieren Sie nun eine Funktion namens greet_user.
In Bash definieren Sie eine Funktion, indem Sie ihren Namen gefolgt von runden Klammern () schreiben und den Codeblock anschließend in geschweifte Klammern {} einschließen.
Eine Funktion gibt einer Gruppe von Befehlen einen wiederverwendbaren Namen. Dadurch werden Shell-Skripte übersichtlicher: Statt überall einzelne Befehle zu sehen, erkennen Sie Aktionen mit aussagekräftigen Namen wie backup_files, check_disk oder greet_user.
Die Syntax sieht folgendermaßen aus:
function_name() {
## Commands to execute
}
Öffnen Sie Ihr Skript erneut:
nano functions.sh
Fügen Sie die folgende Funktionsdefinition unterhalb der Shebang-Zeile ein:
#!/bin/bash
greet_user() {
echo "Hello"
}
Wichtig: Zu diesem Zeitpunkt haben Sie die Funktion nur definiert. Sie haben das Skript noch nicht angewiesen, sie tatsächlich auszuführen. Wenn Sie das Skript jetzt starten würden, würde nichts passieren. Das ist ein häufiger Verständnispunkt für Anfänger: Eine Funktionsdefinition führt die Funktion nicht automatisch aus.
Dieser Unterschied ist wichtig, weil ein Shell-Skript der Reihe nach gelesen und ausgeführt wird. Eine Funktionsdefinition teilt Bash mit, was die Funktion bedeutet. Der Funktionskörper wird jedoch erst ausgeführt, wenn Sie den Funktionsnamen später aufrufen.
Speichern Sie die Datei und beenden Sie den Editor vorerst.
Die Funktion aufrufen
Um den Code innerhalb einer Funktion auszuführen, müssen Sie sie „aufrufen“. In Bash rufen Sie eine Funktion einfach auf, indem Sie ihren Namen in eine neue Zeile schreiben. Beim Aufruf benötigen Sie keine runden Klammern.
Für Anfänger wirkt das oft ungewöhnlich, weil viele Programmiersprachen runde Klammern bei Funktionsaufrufen verwenden. In Bash wird greet_user allein wie ein Befehl behandelt. Wenn eine Funktion mit diesem Namen vorhanden ist, führt Bash den Funktionskörper aus.
Öffnen Sie das Skript:
nano functions.sh
Fügen Sie den Funktionsaufruf am Ende der Datei ein:
#!/bin/bash
greet_user() {
echo "Hello"
}
## The Main Logic starts here
greet_user
Speichern Sie die Datei und beenden Sie den Editor.
Führen Sie nun das Skript aus:
./functions.sh
Beim Ausführen des Skripts sieht die Shell den Befehl greet_user, findet die Funktionsdefinition, führt echo "Hello" aus und fährt anschließend fort.
In diesem Sinne verhält sich eine Funktion ähnlich wie ein eigener Befehl, der nur innerhalb des aktuellen Skripts oder der aktuellen Shell-Sitzung existiert. Deshalb sind Funktionen so nützlich, wenn Sie aus kleineren Shell-Befehlen übergeordnete Aktionen erstellen möchten.
Sie sollten die folgende Ausgabe sehen:
Hello
Argumente an die Funktion übergeben
Eine Funktion, die immer exakt dasselbe tut, etwa "Hello" ausgibt, ist nur begrenzt nützlich. Damit sie flexibler wird, können Sie Daten an sie übergeben. Diese Daten werden als Argument bezeichnet.
Innerhalb einer Funktion können Sie über spezielle Variablen wie $1, $2 usw. auf Argumente zugreifen – genauso wie bei Skriptargumenten.
$1steht für das erste an die Funktion übergebene Argument.$2steht für das zweite Argument usw.
Diese Variablen sind von den eigenen Positionsparametern des Skripts getrennt, sobald die Funktion ausgeführt wird. Anders gesagt: Funktionen können eine eigene kleine Eingabeschnittstelle haben. Dadurch lassen sie sich leichter mit unterschiedlichen Werten wiederverwenden.
Ändern Sie nun die Funktion so, dass sie einen bestimmten Namen begrüßt.
Schritt 1: Funktionsdefinition aktualisieren
Öffnen Sie die Datei:
nano functions.sh
Ändern Sie die Funktion greet_user, sodass sie anstelle einer fest codierten Zeichenfolge $1 verwendet:
greet_user() {
echo "Hello $1"
}
Schritt 2: Funktionsaufruf aktualisieren
Da die Funktion nun ein Argument erwartet, müssen Sie beim Aufruf ein Argument übergeben.
Ändern Sie den Aufruf von greet_user zu greet_user "LabEx".
Ihre Datei sollte jetzt so aussehen:
#!/bin/bash
greet_user() {
echo "Hello $1"
}
greet_user "LabEx"
Speichern Sie die Datei und beenden Sie den Editor.
Schritt 3: Skript testen
Führen Sie das Skript erneut aus:
./functions.sh
Die Ausgabe sollte nun folgendermaßen aussehen:
Hello LabEx
Sie haben damit im Wesentlichen einen eigenen Befehl erstellt, der Eingaben entgegennimmt und verarbeitet. Später im Skript könnten Sie greet_user "Alice" oder greet_user "Bob" aufrufen; die Funktion würde sich entsprechend anpassen.
Zusammenfassung
In diesem Lab haben Sie die Grundlagen von Bash-Funktionen kennengelernt:
- Definieren: Einen benannten Codeblock mit
name() { ... }erstellen. - Aufrufen: Eine Funktion ausführen, indem Sie einfach ihren Namen eingeben.
- Argumente: Daten an die Funktion übergeben und über
$1,$2usw. darauf zugreifen.
Funktionen bilden die Grundlage komplexer Skripte. Sie ermöglichen es Ihnen, Ihre Logik zu strukturieren, Wiederholungen zu vermeiden und Ihren Code leichter les- und wartbar zu machen.
