Du hast beim Aufruf von Programmen schon gesehen, dass du dort Parameter in der Kommandozeile übergeben kannst. Bestes Beispiel ist ls -l bei dem der Parameter -l an das aufgerufene Programm ls übergeben wird, um auf das erweiterte Listing umzuschalten.
| 1 | Einführung |
|---|---|
| 2 | Der bash Prompt |
| 3 | key bindings |
| 4 | Der Startvorgang |
| 5 | Environment Variablen |
| 6 | builtin commands |
| 7 | Arbeiten mit Dateien |
| 8 | nano |
| 9 | bash Scripting |
| 10 | Variablen |
| 11 | Verzweigungen (if) |
| 12 | Schleifen |
| 13 | Kommandozeilenparameter |
| 14 | exit Codes bash Tutorial Teil 14 |
| 15 | von der Idee zum Script |
| 16 | grep |
| 17 | Piping und Redirection |
| 18 | tee |
Parameter in eigenen Scripts
Natürlich kannst du auch an deine eigenen Scripts Werte von der Kommandozeile übergeben. Diese werden in Variablen abgelegt. Wo du sie dann auslesen kannst.
Der Einfachheit-halber sind diese Variablen durchnummeriert von ${0} bis ${99}. Das bedeutet, du kannst deinem Script 100 Parametern gleichzeitig übergeben. Allerdings hat ${0} eine besondere Bedeutung, so dass effektiv 99 noch übrig bleiben.
Fangen wir mit einem einfachen Script an, dass nur die übergebenen Parameter von 0 bis 10 ausgibt.
# testparam.sh
echo " Param #0: ${0}"
echo " Param #1: ${1}"
echo " Param #2: ${2}"
echo " Param #3: ${3}"
echo " Param #4: ${4}"
echo " Param #5: ${5}"
echo " Param #6: ${6}"
echo " Param #7: ${7}"
echo " Param #8: ${8}"
echo " Param #9: ${9}"
echo " Param #10: ${10}"
Aufgerufen wird es dann mit source testparams.sh p1 p2 p3 p4 p5 p6 p7 p8 p9 p10
Das Script zeige dann folgende Ausgabe:
Parameter ${0}
Du siehst hier das eigenwillige Verhalten, dass in Parameter 0 der Wert „-bash“ zu finden ist. Dies hängt damit zusammen, dass der Parameter ${0} den Namen des aufgerufenen Programms enthält. Da wir das Script durch source in einer Subshell gestartet haben,
steht hier bash als Programmname. Als nächstes starten wir dieses Script innerhalb der aktuellen Shell, in dem wir als erste Zeile einen sog. Shebang definieren. Ein Shebang teilt der bash mit, welches Programm benutzt werden soll, um ein Script auszuführen.
Das Script mir Shebang sieht dann so aus
#! /usr/bin/bash
# testparam.sh
echo " Param #0: ${0}"
echo " Param #1: ${1}"
echo " Param #2: ${2}"
echo " Param #3: ${3}"
echo " Param #4: ${4}"
echo " Param #5: ${5}"
echo " Param #6: ${6}"
echo " Param #7: ${7}"
echo " Param #8: ${8}"
echo " Param #9: ${9}"
echo " Param #10: ${10}"
Mit dem Shebang kannst du das Script wie jedes andere Programm direkt von der Kommandozeile starten. Dazu musst du es nur noch als ausführbar kennzeichnen
chmod u+x testparams.shJetzt lässt sich unser Script mit ./testparams.sh p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 direkt starten. Achte darauf, was jetzt im Parameter ${0} steht.
Da jetzt keine neue bash gestartet wird, enthält ${0} den Namen unseres Scripts.
${@}
Es ist eine lästige Arbeit, Alle Parameter in einer Folge von echo Kommandos auszugeben. Die Spezialvariable der bash ${@} enthält alle übergebenen Parameter durch ein Leerzeichen getrennt.
#! /usr/bin/bash
# allparams.sh
echo "${@}"
Jetzt stehen die Parameter allerdings hintereinander. Wir machen uns unser Wissen über Schleifen zu Nutze und iterieren über die Liste der Parameter
#! /usr/bin/bash
#paramloop.sh
let count=0
for p in ${@}; do
echo "Param ${count}: ${p}"
let count=count+1
done
Da in ${@} nur die übergebenen Parameter enthalten sind, ist der Scriptname dort nicht zu finden.
Parameter mit Leerzeichen
Da die verschiedenen Parameter durch ein Leerzeichen voneinander getrennt sind, stellt sich natürlich irgendwann die Frage, wie ein Parameter übergeben wird, der selbst ein Leerzeichen enthält.
Zum einen müssen wir dem Interpreter der bash sagen, dass das folgende Leerzeichen zum Parameter gehört. Dies geschieht üblicherweise entweder durch das Einfassen des gesamten Parameters in Anführungszeichen oder dem Escapen des Leerzeichens durch einen vorangestellten Backslash \. Wenn du das mit dem paramloop.sh probierst, wirst feststellen, das dort trotzdem an den maskierten Leerzeichen die Parameter aufgetrennt werden.
Die Lösung für dieses Problem ist ganz einfach und ein Kniff, den du im Hinterkopf behalten solltest. In der Schleife fassen wir die Parameterliste auch noch in Anführungszeichen ein for p in "${@}"; do. Dann wird jeder Name mit Nachnamen in einen Parameter gepackt. Dies solltest du gerade bei Parametern, die einen Dateinamen enthalten, immer machen!
" verpackt, bringt uns das gewünschte Ergebnis