Das Parsen und Übergeben von Argumenten an Bash-Skripte/Shell-Skripte ähnelt der Art und Weise, wie wir Argumente an die Funktionen in Bash-Skripten übergeben. Wir sehen uns den eigentlichen Prozess der Weitergabe der Argumente an ein Skript an und schauen uns auch an, wie man innerhalb des Skripts auf diese Argumente zugreift.

Übergabe von Argumenten vor der Ausführung

Wir können Parameter direkt nach dem Namen des Skripts übergeben, während wir den Bash-Interpreter-Befehl ausführen. Sie können Parameter oder Argumente an die Datei übergeben. Nur der Befehl zum normalen Ausführen des Skripts, indem der Wert der Parameter direkt zum Skript hinzugefügt wird. Jeder Parameter ist ein durch Leerzeichen getrennter Wert, der an das Shell-Skript übergeben wird.

bash scriptname.sh 

Der obige Befehl führt einfach das Skript aus, ohne die Parameter zu übergeben.

Der folgende Befehl hingegen übergibt die Argumente an das Skript.

bash scriptname.sh parameter1 parameter2 parameter3 nth-parameter 

Ausführen eines Bash-Skripts mit Übergabe von Parametern

Der obige Screenshot zeigt die an das Skript übergebenen Parameter und wie wir das machen, was wir im nächsten Abschnitt erklären. Aber jetzt können wir sehen, dass wir die Parameter mithilfe von Bash-Umgebungsvariablen von außerhalb des Skripts übergeben haben. Sie können sogar Zeichenfolgen und andere Datentypen verwenden, achten Sie jedoch auf Leerzeichen. Durch Leerzeichen wird die Variable zu einem separaten Parameter. Achten Sie daher insbesondere bei Zeichenfolgen darauf, diese unbedingt in Anführungszeichen zu setzen.

Befehlszeilenargumente erkennen

Jetzt werden wir sehen, wie wir innerhalb des Skripts auf diese Parameter zugreifen. Wir verwenden die Anzahl der in der Reihenfolge übergebenen Parameter, d. h. für die ersten übergebenen Parameter analysieren wir den Parameter (greifen darauf zu), indem wir $1 als Variable verwenden. Der erste Parameter wird in der Variablen $1 gespeichert. Darüber hinaus können Sie diese Variable einer beliebigen anderen benutzerdefinierten Variablen zuweisen. Für den übergebenen n-ten Parameter können Sie mit $n auf diesen bestimmten Parameter zugreifen. Hier beginnt der Variablenname mit 1, da der Dateiname/Skriptname der 0. Parameter ist. Wenn Sie mehr als 9 Parameter haben, stellen Sie sicher, dass Sie { } um die Zahl herum verwenden, da Bash ohne Klammern nur $10 als $1 sieht und die 0 ausschließt. Verwenden Sie also ${10} usw. statt einfach $10.

#!/bin/bash echo '1st parameter = $1 ' echo '2nd Parameter = $2 ' 

Das obige Skript kann über die Befehlszeile/Shell auf die Parameter zugreifen, indem es die Positionsparameter 1, 2, 3 usw. verwendet.

Zugriff auf die Argumente über das Skript.

Wie Sie sehen, haben wir {} verwendet, um auf die Parametervariablennummern ab 10 zuzugreifen. Das Skript kann zum Durchlaufen der Parameter mit for-Schleifen und while-Schleifen verwendet werden, wir werden es jedoch in weiteren Abschnitten besprechen.

Weisen Sie der Bash-Variablen bereitgestellte Argumente zu

Wir können es auch anderen benutzerdefinierten Variablen zuweisen, um das Skript dynamischer zu gestalten und es entsprechend den Anforderungen anzupassen. Obwohl das obige Skript bei der Ausführung nur zwei Parameter ausgibt, können Sie sicherlich auf weitere Parameter zugreifen, indem Sie die Variable als Reihenfolge der Parameter in Zahlen verwenden. Das Skript kann über die Befehlszeile auf die Positionsvariablen zugreifen und diese an den erforderlichen Stellen überall im Skript verwenden.

#!/bin/bash a=$1 b=$2 p=$(($a*$b)) echo 'The product of $a and $b = $p' 

Weisen Sie der Bash-Variablen bereitgestellte Argumente zu

Das obige Skript greift auf die Positionsparameter zu, d. h. $1 und $2, die an das Skript übergeben wurden, und speichert die benutzerdefinierten Variablen, um später darauf zuzugreifen und sie entsprechend zu ändern. Wir können auch mithilfe iterativer Methoden auf weitere Parameter zugreifen, wie wir in den nächsten Abschnitten sehen werden.

Wir haben auch die Möglichkeit, mithilfe der Flags -z oder -n nach NULL- oder leeren Parametern zu suchen. Daraus können wir überprüfen, ob die Parameter übergeben wurden oder nicht.

#!/bin/bash if [[ -z $1 ]]; then echo 'No parameter passed.' else echo 'Parameter passed = $1' fi 

Es wird überprüft, ob Positionsparameter übergeben wurden oder nicht.

Mit diesem Skript können wir erkennen, ob Positionsparameter übergeben wurden oder nicht. Das Flag -z prüft, ob in BASH NULL-Variablen oder nicht initialisierte Variablen vorhanden sind. Das Flag -z gibt true zurück, wenn die übergebene Variable NULL oder nicht initialisiert ist. Daher können wir grundlegende If-else-Anweisungen verwenden, um die übergebenen Parameter zu erkennen.

Wir können auch das Flag -n verwenden, das „true“ zurückgibt, wenn keine Parameter übergeben werden, also müssen wir es verwenden! um den Zustand umzukehren.

Wie folgt:

#!/bin/bash if [[ ! -n $1 ]]; then echo 'No parameter passed.' else echo 'Parameter passed = $1' fi 

Auch dieses Skript liefert die gleiche Ausgabe, wir verwenden jedoch das Flag -n anstelle von -z.

Lesen mehrerer Argumente mit einer For- oder While-Schleife

Wir können die @-Variable verwenden, um auf jeden Parameter zuzugreifen, der über die Befehlszeile an das Skript übergeben wird. Es handelt sich um eine spezielle Variable, die das Array von Variablen in BASH enthält. In diesem Fall verwenden wir es allein, sodass es das Array der übergebenen Positionsparameter enthält. Wir können es verwenden, um die übergebenen Parameter mithilfe von Schleifen oder einer While-Schleife zu durchlaufen.

#!/bin/bash for i in $@ do echo -e '$i
' done 

Verwenden von Schleifen und @-Variablen, um auf die Parameter als Array-Elemente zuzugreifen.

Wir haben eine bereichsbasierte for-Schleife verwendet, um zu iterieren, bis Elemente im @-Array vorhanden sind. Wir durchlaufen einfach das Array und geben das Element aus. Wir können es einfach zuweisen, die Werte ändern und die erforderlichen Änderungen an den Parametern und Argumenten vornehmen, um das gewünschte Ergebnis des Skripts zu erzielen.

ODER

Wir können die Argumente auch mit der while-Schleife und den Umgebungsvariablen von BASH ausgeben.

#!/bin/bash i=$(($#-1)) while [ $i -ge 0 ]; do echo ${BASH_ARGV[$i]} i=$((i-1)) done 

Verwenden einer While-Schleife zum Durchlaufen der übergebenen Parameter.

Wir verwenden die Variable „ # ‘, da es die Anzahl der übergebenen Parameter enthält. Wir initialisieren die Anzahl der Parameter und entfernen einen, da wir ein Array verwenden werden, um darüber zu iterieren. Der Index des Arrays beginnt also wie üblich bei 0. Da dieses Array mit dem letzten übergebenen Element oder Parameter initialisiert wird, müssen wir den Zähler bis 0 dekrementieren, um jeden Parameter in der Reihenfolge auszugeben, in der er übergeben wurde. Wir verwenden einfach das Array BASH_ARGV, um auf die Parameter zuzugreifen und ihren Wert auszugeben. Außerdem verringern wir bei jeder Iteration den Wert von i – dem Iterator oder Zähler – um eins, indem wir die arithmetischen doppelten Klammern verwenden. Von hier aus drucken wir einfach jeden an das Skript übergebenen Parameter mithilfe einer While-Schleife aus, wie im Ausgabe-Screenshot gezeigt.

Lesen mit Parameternamen

Verwenden von getopts zum Parsen von Argumenten und Parametern

Wir können das Programm/den Befehl getopts verwenden, um die an das Skript in der Befehlszeile/im Terminal übergebenen Argumente mithilfe von Schleifen und Switch-Case-Anweisungen zu analysieren.

#!/bin/bash while getopts n:c: option do case '${option}' in n)nation=${OPTARG};; c)code=${OPTARG};; esac done echo 'Nation : $nation' echo 'code : $code' 

Verwenden von getopts zum Parsen von Argumenten und Parametern

Mit getopts können wir die Positionsargumente/Parameter von der Befehlszeile direkt den Bash-Variablen zuweisen. Dadurch können wir die Parameter gut und systematisch verwalten. Im obigen Skript haben wir zwei Argumente verwendet, um die Bash-Variablen mithilfe der getopts-Syntax, While-Schleifen und Switch-Case-Anweisungen zu speichern.

Werte aller Argumente drucken

Wir können die an das Skript übergebenen Argumente durch eine einfache leistungsstarke Variable „@“ drucken, die alle übergebenen Parameter speichert.

#!/bin/bash echo 'The arguments passed in are : $@' 

Werte aller Argumente drucken

Zugriff auf die Anzahl der übergebenen Parameter

Wir können auch die Variable „#“ verwenden, um auf die Anzahl der von der Befehlszeile übergebenen Parameter zuzugreifen. Die Variable # enthält grundsätzlich die Anzahl der Parameter/Argumente, die an das Skript übergeben werden.

#!/bin/bash echo 'The number of arguments passed in are : $#' 

Zugriff auf die Anzahl der übergebenen Parameter

Im Folgenden werden der Prozess und die Spezifikation der Übergabe und Analyse der Variablen im Bash-Skript beschrieben. Die Logik des Verschiebens und Vornehmens von Änderungen an den Variablen liegt in der Hand des Benutzers. Dies war lediglich eine Demonstration der Übergabe und Analyse der Argumente von der Befehlszeile an das Skript, um sie dynamischer zu gestalten.