Argumente an das Skript übergeben

Einführung

In der Shell-Programmierung ist die Fähigkeit, Argumente an ein Skript zu übergeben, eine grundlegende und leistungsstarke Funktion. Sie ermöglicht es, Skripte flexibler und wiederverwendbar zu gestalten, indem Eingaben direkt über die Befehlszeile entgegengenommen werden. Dieses Lab führt Sie durch den Prozess der Erstellung eines Shell-Skripts, das Befehlszeilenargumente akzeptieren und verwenden kann. Sie lernen, wie Sie innerhalb Ihres Skripts auf diese Argumente zugreifen, mit mehreren Argumenten umgehen und spezielle Variablen nutzen, um diese effizient zu verarbeiten.

Eine neue Skriptdatei erstellen

Beginnen wir mit der Erstellung einer neuen Skriptdatei. Wir verwenden für dieses Lab die WebIDE (VS Code).

1. Öffnen Sie die WebIDE, falls sie noch nicht geöffnet ist.
2. Navigieren Sie im Datei-Explorer auf der linken Seite zum Verzeichnis /home/labex/project.
3. Klicken Sie mit der rechten Maustaste in den Datei-Explorer und wählen Sie "New File".
4. Benennen Sie die neue Datei arguments.sh.

Nachdem wir die Datei erstellt haben, fügen wir die Grundstruktur unseres Skripts hinzu:

#!/bin/bash

## Your code will go here

Die erste Zeile wird als "Shebang" oder "Hashbang" bezeichnet. Sie teilt dem System mit, welcher Interpreter zur Ausführung des Skripts verwendet werden soll. In diesem Fall nutzen wir bash.

Für Anfänger: Die Shebang-Zeile ist wichtig, da sie es Ihnen ermöglicht, das Skript direkt auszuführen (z. B. mit ./arguments.sh), anstatt jedes Mal bash arguments.sh tippen zu müssen. Es ist ein kleines Detail, das die Verwendung Ihrer Skripte jedoch erheblich komfortabler macht.

Auf Skriptargumente zugreifen

Nun modifizieren wir unser Skript so, dass es auf die übergebenen Argumente zugreift und diese anzeigt. In der Shell-Programmierung werden spezielle Variablen verwendet, um auf Befehlszeilenargumente zuzugreifen:

• $0 repräsentiert den Namen des Skripts selbst.
• $1, $2, $3 usw. repräsentieren das erste, zweite, dritte Argument und so weiter.

Fügen Sie den folgenden Code in Ihre Datei arguments.sh ein:

#!/bin/bash

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "Third argument: $3"

Dieses Skript zeigt den Skriptnamen und die ersten drei übergebenen Argumente an.

Für Anfänger:

• Das Symbol $ wird verwendet, um in der Bash auf Variablen zu verweisen.
• $0, $1, $2 usw. sind spezielle Variablen, die von der Bash automatisch gesetzt werden, wenn Sie ein Skript mit Argumenten ausführen.
• Wenn Sie das Skript ohne Argumente ausführen, bleiben $1, $2 und $3 leer, aber das Skript wird dennoch ohne Fehler ausgeführt.

Das Skript ausführbar machen

Bevor wir unser Skript ausführen können, müssen wir es ausführbar machen. Dies geschieht mit dem Befehl chmod. Navigieren Sie im Terminal zum Projektverzeichnis und führen Sie den folgenden Befehl aus:

cd /home/labex/project
chmod +x arguments.sh

Der Befehl chmod +x fügt der Datei Ausführungsrechte hinzu, sodass sie als Skript gestartet werden kann.

Für Anfänger:

• chmod steht für "change mode" (Modus ändern). Es wird verwendet, um die Berechtigungen einer Datei oder eines Verzeichnisses zu ändern.
• Die Option +x fügt die Ausführungsberechtigung hinzu. Dies ist notwendig, damit die Bash die Datei als Programm ausführen kann.
• Wenn Sie diesen Schritt vergessen, erhalten Sie die Fehlermeldung "permission denied" (Berechtigung verweigert), wenn Sie versuchen, Ihr Skript zu starten.

Das Skript mit Argumenten ausführen

Da unser Skript nun ausführbar ist, lassen Sie es uns mit einigen Argumenten testen. Führen Sie im Terminal den folgenden Befehl aus:

./arguments.sh hello world example

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Script name: ./arguments.sh
First argument: hello
Second argument: world
Third argument: example

Diese Ausgabe zeigt, dass unser Skript erfolgreich auf die Befehlszeilenargumente zugegriffen und diese ausgegeben hat.

Für Anfänger:

• Das ./ vor dem Skriptnamen weist die Bash an, im aktuellen Verzeichnis nach dem Skript zu suchen.
• Jedes Wort nach dem Skriptnamen wird zu einem separaten Argument. In diesem Fall ist "hello" das erste, "world" das zweite und "example" das dritte Argument.
• Wenn Sie ein Argument übergeben möchten, das Leerzeichen enthält, müssen Sie es in Anführungszeichen setzen, zum Beispiel so: ./arguments.sh "hello world" example

Die Anzahl der Argumente verarbeiten

Lassen Sie uns unser Skript so anpassen, dass es unterschiedlich auf die Anzahl der übergebenen Argumente reagiert. Wir verwenden dazu die spezielle Variable $#, welche die Gesamtzahl der an das Skript übergebenen Argumente enthält.

Aktualisieren Sie Ihre Datei arguments.sh mit folgendem Inhalt:

#!/bin/bash

if [ $## -eq 0 ]; then
  echo "No arguments provided."
elif [ $## -eq 1 ]; then
  echo "One argument provided: $1"
elif [ $## -eq 2 ]; then
  echo "Two arguments provided: $1 and $2"
else
  echo "More than two arguments provided:"
  echo "First argument: $1"
  echo "Second argument: $2"
  echo "Third argument: $3"
  echo "Total number of arguments: $#"
fi

Dieses Skript nutzt bedingte Anweisungen, um je nach Anzahl der Argumente unterschiedliche Ausgaben zu erzeugen.

Für Anfänger:

• $# ist eine spezielle Variable, die die Anzahl der übergebenen Argumente speichert.
• [ $## -eq 0 ] ist eine Bedingung, die prüft, ob die Anzahl der Argumente gleich 0 ist.
• elif ist die Abkürzung für "else if". Es erlaubt Ihnen, mehrere Bedingungen nacheinander zu prüfen.
• Der Operator -eq bedeutet "equal to" (gleich). Es gibt weitere Operatoren wie -lt (less than / kleiner als), -gt (greater than / größer als) usw.

Das aktualisierte Skript testen

Testen wir nun unser aktualisiertes Skript mit einer unterschiedlichen Anzahl von Argumenten:

./arguments.sh
./arguments.sh one
./arguments.sh one two
./arguments.sh one two three four

Sie sollten je nach Anzahl der bereitgestellten Argumente unterschiedliche Ausgaben sehen.

Für Anfänger:

• Das Ausführen des Skripts ohne Argumente (./arguments.sh) löst die erste Bedingung in unserem Skript aus.
• Jeder nachfolgende Befehl fügt mehr Argumente hinzu und demonstriert, wie unser Skript verschiedene Fälle handhabt.
• Beachten Sie, wie sich das Verhalten des Skripts basierend auf der Anzahl der Argumente ändert. Diese Art von Flexibilität ist in der Praxis äußerst nützlich.

Alle Argumente in einer Schleife durchlaufen

Abschließend modifizieren wir unser Skript so, dass es alle übergebenen Argumente mithilfe einer Schleife durchläuft. Dafür nutzen wir die spezielle Variable $@, die alle Befehlszeilenargumente repräsentiert.

Aktualisieren Sie Ihre Datei arguments.sh mit folgendem Inhalt:

#!/bin/bash

echo "Total number of arguments: $#"
echo "All arguments:"

count=1
for arg in "$@"; do
  echo "Argument $count: $arg"
  count=$((count + 1))
done

Dieses Skript verwendet eine for-Schleife, um über alle Argumente zu iterieren und sie zusammen mit ihrer Position anzuzeigen.

Für Anfänger:

• $@ ist eine spezielle Variable, die alle an das Skript übergebenen Argumente enthält.
• Die for-Schleife wird verwendet, um eine Liste von Elementen abzuarbeiten. In diesem Fall iteriert sie über alle Argumente.
• $((count + 1)) ist eine arithmetische Erweiterung in der Bash. Sie wird hier verwendet, um den Wert der Variable count zu erhöhen.
• Dieses Skript funktioniert mit einer beliebigen Anzahl von Argumenten und ist damit wesentlich flexibler als unsere vorherigen Versionen.

Das finale Skript testen

Testen wir unser finales Skript mit mehreren Argumenten:

./arguments.sh apple banana cherry date

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Total number of arguments: 4
All arguments:
Argument 1: apple
Argument 2: banana
Argument 3: cherry
Argument 4: date

Dies zeigt, dass unser Skript nun jede beliebige Anzahl von Argumenten verarbeiten und einzeln auflisten kann.

Für Anfänger:

• Diese finale Version des Skripts ist viel flexibler als unsere ersten Entwürfe.
• Es kann mit null bis beliebig vielen Argumenten umgehen.
• Das Skript nummeriert nun jedes Argument, was in komplexeren Skripten sehr hilfreich sein kann.
• Versuchen Sie, das Skript mit verschiedenen Argumenten zu füttern, um zu sehen, wie es reagiert.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man ein Shell-Skript erstellt, das Befehlszeilenargumente akzeptiert und verarbeitet. Sie haben dabei mehrere Schlüsselkonzepte kennengelernt:

1. Erstellen und Ausführbarmachen eines Skripts.
2. Zugriff auf einzelne Argumente über spezielle Variablen ($1, $2 usw.).
3. Verwendung der Variable $#, um die Anzahl der Argumente zu ermitteln.
4. Implementierung von bedingter Logik zur Handhabung unterschiedlicher Argumentmengen.
5. Nutzung der Variable $@, um alle übergebenen Argumente in einer Schleife zu durchlaufen.

Diese Fähigkeiten sind grundlegend für die Shell-Programmierung. Sie ermöglichen es Ihnen, vielseitige und leistungsstarke Skripte zu schreiben, die sich an verschiedene Eingaben anpassen können. Während Sie Ihre Kenntnisse weiter vertiefen, werden Sie feststellen, dass der sichere Umgang mit Befehlszeilenargumenten entscheidend für die Automatisierung und Systemadministration ist.