Hi! Dieser Artikel ist der zweite Teil der Howtoforge-Shell-Scripting-Tutorial-Reihe. Zu diesem Zeitpunkt gehe ich davon aus, dass Sie den ersten Teil der Reihe gelesen haben und wissen, wie man ein einfaches Skript erstellt und ausführt. Im zweiten Teil erfahren Sie, wie Sie Eingaben vom Benutzer akzeptieren und sie durch Shell-Skripting verarbeiten. Fangen wir an!
Variablen in Linux
Genau wie Programmiersprachen hat die Linux-Shell die Fähigkeit, Daten in Variablen zu speichern. Eine Variable ist ein Container, der vorübergehend Daten speichert, die durch eine Programmiersprache verarbeitet werden. Es gibt zwei Arten von Variablen in Linux:die Umgebungsvariablen und Shell-Variablen.
Umgebungsvariablen
Die Umgebungsvariablen sind die Standardvariablen in Linux und werden verwendet, um Informationen zwischen Prozessen in der Shell zu übergeben. Bei Umgebungsvariablen wird zwischen Groß- und Kleinschreibung unterschieden und sie sollten immer groß geschrieben werden, um auf sie zugreifen zu können.
Die folgende Tabelle zeigt die allgemeinen Umgebungsvariablen in der Linux-Shell:
| Variablenname | Nutzung |
| BASH | Enthält den vollständigen Pfad des Befehlsinterpreters für Bash-Skripte |
| BASH_VERSION | Enthält die Bash-Release-Version der aktuell verwendeten Maschine |
| STARTSEITE | Enthält den relativen Pfad des Home-Verzeichnisses. |
| LOGNAME | Hält den Kontonamen des aktuell angemeldeten Benutzers |
| OSTYP | Enthält eine Zeichenfolge, die das aktuelle Betriebssystem des verwendeten Computers beschreibt |
| PFAD | Enthält einen durch Doppelpunkte getrennten absoluten Pfad der ausführbaren Dateien in Linux |
| PWD | Enthält das aktuelle Arbeitsverzeichnis der Shell |
| SCHALE | Enthält die bevorzugte Befehlszeilen-Shell |
| BENUTZER | Funktioniert ähnlich wie LOGNAME. Es enthält den Kontonamen des aktuell angemeldeten Benutzers |
| _ | Hält den Namen des zuletzt verwendeten Befehls in der Shell |
Um den Wert einer Umgebungsvariablen anzuzeigen, muss der Nutzer der Variablen, auf die zugegriffen werden soll, ein Dollarzeichen ($) voranstellen. Um beispielsweise einige Systeminformationen wie das aktuelle Arbeitsverzeichnis, den angemeldeten Benutzer und den Betriebssystemtyp mit Echo anzuzeigen, verwenden wir:
#!/bin/bash
echo $PWD
echo $LOGNAME
echo $OSTYPE
Das Ergebnis ist:
Um die gesamte Liste der Umgebungsvariablen unter Linux abzurufen, verwenden Sie den Befehl env.
Werte von Umgebungsvariablen ändern
Um Systemflexibilität bereitzustellen, können diese Umgebungsvariablen manipuliert werden. Um einer Umgebungsvariablen einen Wert zuzuweisen, verwenden Sie einen Zuweisungsausdruck (Gleichheitszeichen).
Beispiel:
#!/bin/bash
echo $USER
USER="new user"
echo $USER
Das Ergebnis des Skripts ist:
Wenn Sie das Skript ausführen, zeigt $USER in der Zeile echo $USER zunächst den Wert der USER-Variablen an. Durch die Verwendung eines Zuweisungsoperators (=) ändert die USER-Variable ihren Wert. Wenn der Benutzer jedoch einer Umgebungsvariablen unbekannte Werte zuweist, erstellt die Shell eine weitere Shell-Variable, die der Umgebungsvariablen im lokalen Kontext des Skripts ähnelt, aber das Verhalten anderer Anwendungen wird dadurch nicht beeinflusst. Das heißt, sobald unser Skript geschlossen wird, behält die USER-Variable ihren Standardwert.
Beachten Sie, dass wir in unserem vorherigen Beispiel das Dollarzeichen ($) im Variablennamen weglassen, wenn wir Werte der Umgebungsvariablen manipulieren, wie z. B. die Zeile USER="new user". Außerdem darf bei Verwendung des Zuweisungsoperators kein Leerzeichen zwischen dem USER- und dem =-Zeichen stehen. Das Einfügen eines Leerzeichens zwischen ihnen erzeugt einen Fehler.
Shell-Variablen
Die Shell ermöglicht es dem Benutzer auch, Variablen zu deklarieren. Genau wie bei PHP muss sich der Benutzer, um eine Variable in Shell-Skripten zu deklarieren, nicht um die Deklaration ihres Datentyps kümmern; Der Interpreter erkennt automatisch den Datentyp der Variablen basierend auf den Daten, die der Benutzer während der Laufzeit darin speichert.
Regeln zur Benennung von Shell-Variablen
Wie bei jeder Programmiersprache gibt es Regeln bei der Benennung von Shell-Variablen. Im Folgenden werden die Regeln zusammengefasst:
- Die Namen von Variablen müssen mit einem Buchstaben oder einem Unterstrich beginnen.
- Es darf nur alphanumerische Zeichen oder einen Unterstrich enthalten.
- Bei Variablen wird zwischen Groß- und Kleinschreibung unterschieden, daher sind die Variablen path, PATH und Path unterschiedlich.
Um diese Regel zu beweisen, erstellen wir unten ein einfaches Skript:
#!/bin/bash
12abc=10
abc#*=10
_abc=10
_ABC=2
echo $12abc $abc#* $_abc $_ABC
Die Zeilen 2 und 3 geben den Fehler "Befehl nicht gefunden" zurück, weil die Variable 12abc mit einem numerischen Zeichen beginnt und die Variable abc#* unzulässige Zeichen enthält. Wir haben auch bewiesen, dass _abc und _ABC unterschiedliche Variablen sind und die Zeile _ABC=2 den Wert von _abc nicht überschreibt.
Zuweisen von Werten zu Shell-Variablen mit dem Lesebefehl:
read ist ein Befehl, der es ermöglicht, Eingaben vom Benutzer zu akzeptieren. Die Syntax bei der Verwendung des Lesebefehls lautet:
read <variable_name>
Beispielsweise werden wir ein Skript erstellen, das es einem Benutzer ermöglicht, seinen Vor- und Nachnamen einzugeben und anzuzeigen. Um dem Benutzer mitzuteilen, was zu tun ist, zeigen wir eine Benutzeraufforderung mit dem echo-Befehl.
#!/bin/bash
echo "Your first name: "
read fname
echo "Your last name:"
read lname
echo "Hello $fname $lname ! I am learning how to create shell scripts."
Das Ergebnis ist:
Bitte beachten Sie, dass wir wie in unserem vorherigen Beispiel keine Variable deklarieren müssen, um sie zu verwenden. Der Interpreter erstellt auch automatisch die Variable, die im Lesebefehl verwendet wird. In dem Beispiel haben wir jedoch wiederholt den echo-Befehl verwendet, um eine Eingabeaufforderung für den Benutzer zu erstellen. Der Lesebefehl hat auch die Fähigkeit, eine Eingabeaufforderung zu erstellen, während Benutzereingaben akzeptiert werden. Die Syntax für die Verwendung von prompt im Lesebefehl lautet:
read -p "Your prompt: " <variable_name>
Um unseren vorherigen Code zu vereinfachen, können wir den Code wie folgt rekonstruieren:
#!/bin/bash
read -p "Your first name: " fname
read -p "Your last name: " lname
echo "Hello $fname $lname ! I am learning how to create shell scripts"
Ein weiterer Vorteil des read-Befehls ist, dass die Eingabeaufforderung direkt hinter dem Text steht und nicht in der Zeile darunter.
Der Lesebefehl kann auch zum Akzeptieren von Passwörtern verwendet werden. Im Gegensatz zu gewöhnlichen Eingaben werden Passwörter aus Sicherheitsgründen maskiert. Die Syntax beim Akzeptieren eines Passworts lautet:
read -s -p "your prompt" <variable_name>
Einfache Arithmetik mit der Shell durchführen
Neben dem Akzeptieren von Eingaben und dem Anzeigen von Ausgaben hat die Bash-Shell auch eine eingebaute arithmetische Option. Die folgende Tabelle fasst die eingebauten arithmetischen Operatoren der Bash-Shell zusammen.
| Operator | Beschreibung | Syntax | Nutzung |
| + | Zusatz | a=$((b+c)) | Addiert den Wert von b und c und speichert ihn in Variable a |
| - | Subtraktion | a=$((b-c)) | Subtrahiert den Wert von c von b und speichert ihn in Variable a |
| * | Multiplikation | a=$((b*c)) | Multipliziert den Wert von b und c und speichert ihn in Variable a |
| / | Abteilung | a=$((b/c)) | Teilt den Wert von b durch c und speichert ihn in der Variablen a |
| % | Modul | a=$((b%c)) | Führt eine Modulo-Division von b und c durch und speichert sie in Variable a |
| ++ | Vorinkrement | $((++aa)) | Inkrementiert den Wert der Variablen a sofort |
| ++ | Post-Inkrement | $((a++)) | Inkrementiert den Wert von Variable a und gibt Änderungen in der nächsten Zeile wieder |
| -- | Pre-Dekrement | $((--a)) | Verringert den Wert der Variablen a sofort |
| -- | Post-Dekrement | $((a--)) | Verringert den Wert von Variable a und gibt Änderungen in der nächsten Zeile wieder |
| ** | Potenzierung | $((a**2)) | Erhöhen Sie den Wert von a auf den Exponenten von 2 |
| += | Plus gleich | $((a+=b)) | Addiert den Wert von a und b und speichert ihn in der Variablen a |
| -= | Minus gleich | $((a-=b)) | Subtrahiert den Wert von b von a und speichert ihn in der Variablen a |
| *= | Mal gleich | $((a*=b)) | Multipliziert den Wert von a und b und speichert ihn in Variable a |
| /= | Schrägstrich gleich | $((a/=b)) | Teilt den Wert von a durch b und speichert ihn in der Variablen a |
| %= | Mod-gleich | $((a%=b)) | Durchführen einer Modulo-Division zwischen a und b und Speichern in Variable a |
Beachten Sie, dass jedes Mal, wenn Sie eine arithmetische Anweisung ausführen, alle unsere Variablen in ein Dollarzeichen und doppelte Klammern eingeschlossen werden. Dadurch behandelt der Interpreter die Werte unserer Variablen als ganze Zahlen. Ohne sie behandelt der Interpreter die Werte der Variablen als Zeichenfolge. Ein Beispiel finden Sie im folgenden Skript:
#!/bin/bash
read -p "Enter int1: " a
read -p "Enter int2: " b
echo $((a+b))
c=$a+$b
echo $c
Wenn wir unser Beispiel ausführen, fügt die Zeile $((a+b)) die Werte des Benutzers hinzu, die in den Variablen a bzw. b gespeichert sind, während c=$a+$b die Variablen a und b als String behandelt.
Schlussfolgerung
Wir haben behandelt, wie Eingaben akzeptiert und in einer Variablen gespeichert werden und wie arithmetische Operationen in Bash-Shell-Skripten ausgeführt werden. Im nächsten Teil werden wir Kontrollstrukturen und insbesondere die Entscheidungsstruktur vorstellen.
Referenzen:
Das Linux-Informationsprojekt. (2007). Abgerufen am 29. April 2015 von Linfo.org: http://www.linfo.org/
Cooper, M. (ohne Datum). Erweitertes Bash-Skripting-Handbuch. Abgerufen am 29. April 2015 von http://www.tldp.org/LDP/abs/html/
Umgebungsvariablen. (n.d.). Abgerufen am 29. April 2015 aus der Ubuntu-Dokumentation: https://help.ubuntu.com/community/EnvironmentVariables