Wie kann ich ein Befehlszeilenargument an ein Shell-Skript übergeben?

Ich weiß, dass Shell-Skripte nur Befehle ausführen, als ob sie an der Eingabeaufforderung ausgeführt wurden. Ich möchte in der Lage sein, Shell-Skripte so auszuführen, als wären sie Funktionen ... Das heißt, einen Eingabewert oder eine Zeichenfolge in das Skript aufzunehmen. Wie gehe ich das an?

Der Shell - Befehl und alle Argumente zu diesem Befehl erscheinen als nummerieren Shell - Variablen: $0den String - Wert des Befehls selbst, so etwas wie script, ./script, /home/user/bin/scriptoder was auch immer. Alle Argumente erscheinen als "$1", "$2", "$3"und so weiter. Die Anzahl der Argumente ist in der Shell-Variablen angegeben "$#".

Zu den gebräuchlichen Vorgehensweisen gehören Shell-Befehle getoptsund shift. getoptsist der C- getopt()Bibliotheksfunktion sehr ähnlich . shiftVerschiebt den Wert von $2nach $1, $3nach $2und so weiter. $#wird dekrementiert. Code untersucht am Ende den Wert von "$1", erledigt Dinge mit a case… esac, um eine Aktion zu bestimmen, und macht dann a shift, um $1zum nächsten Argument zu gelangen. Es muss immer nur prüfen $1, und vielleicht $#.

Sie können auf übergebene Argumente zugreifen, $nwobei ndie Argumentnummer - ist 1, 2, 3, .... Sie übergeben die Argumente wie bei jedem anderen Befehl.

$ cat myscript
#!/bin/bash
echo "First arg: $1"
echo "Second arg: $2"
$ ./myscript hello world
First arg: hello
Second arg: world

$/shellscriptname.sh argument1 argument2 argument3 

Sie können die Ausgabe eines Shell-Skripts auch als Argument an ein anderes Shell-Skript übergeben.

$/shellscriptname.sh "$(secondshellscriptname.sh)"

Innerhalb von Shell-Skripten können Sie auf Argumente mit Zahlen wie $1für das erste Argument und $2für das zweite Argument usw. zugreifen .

Mehr zu Shell-Argumenten

Die Form

$ ./script.sh "$@" 

ist am bequemsten für argv. Das Arg-Trennzeichen ist ein Leerzeichen, das jedoch geändert werden kann. Ich erinnere mich nicht, wie ungeschickt. Dann benutze

 $1, $2, shift, if [ $# -ne 3 ] 

um den Fluss zu kontrollieren. Ich gehe normalerweise nicht auf Getopts ein, wenn ein case ... esacWille ausreicht.

In einem Bash-Skript verwende ich persönlich gerne das folgende Skript, um Parameter festzulegen:

#!/bin/bash

helpFunction()
{
   echo ""
   echo "Usage: $0 -a parameterA -b parameterB -c parameterC"
   echo -e "\t-a Description of what is parameterA"
   echo -e "\t-b Description of what is parameterB"
   echo -e "\t-c Description of what is parameterC"
   exit 1 # Exit script after printing help
}

while getopts "a:b:c:" opt
do
   case "$opt" in
      a ) parameterA="$OPTARG" ;;
      b ) parameterB="$OPTARG" ;;
      c ) parameterC="$OPTARG" ;;
      ? ) helpFunction ;; # Print helpFunction in case parameter is non-existent
   esac
done

# Print helpFunction in case parameters are empty
if [ -z "$parameterA" ] || [ -z "$parameterB" ] || [ -z "$parameterC" ]
then
   echo "Some or all of the parameters are empty";
   helpFunction
fi

# Begin script in case all parameters are correct
echo "$parameterA"
echo "$parameterB"
echo "$parameterC"

Bei dieser Struktur verlassen wir uns nicht auf die Reihenfolge der Parameter, da wir für jeden einen Schlüsselbuchstaben definieren. Außerdem wird die Hilfefunktion immer dann gedruckt, wenn die Parameter falsch definiert sind. Es ist sehr nützlich, wenn wir viele Skripte mit unterschiedlichen Parametern haben. Es funktioniert wie folgt:

$ ./myscript -a "String A" -b "String B" -c "String C"
String A
String B
String C

$ ./myscript -a "String A" -c "String C" -b "String B"
String A
String B
String C

$ ./myscript -a "String A" -c "String C" -f "Non-existent parameter"
./myscript: illegal option -- f

Usage: ./myscript -a parameterA -b parameterB -c parameterC
    -a Description of what is parameterA
    -b Description of what is parameterB
    -c Description of what is parameterC

$ ./myscript -a "String A" -c "String C"
Some or all of the parameters are empty

Usage: ./myscript -a parameterA -b parameterB -c parameterC
    -a Description of what is parameterA
    -b Description of what is parameterB
    -c Description of what is parameterC

./myscript myargument

myargumentwird $1drinnen myscript.

Im Shell-Skript; es wird der Variablenname $ 1. Das zweite Wort wird zum Variablennamen $ 2 und so weiter.

cat << 'EOF' > test
echo "First arg: $1"
echo "Second arg: $2"
echo "List of all arg: $@"
EOF
sh test hello world

Weitere Informationen finden Sie im Shell-Handbuch (sh) unter http://heirloom.sourceforge.net/sh/sh.1.html

Wenn Sie mit Python argparse vertraut sind und es Ihnen nichts ausmacht, Python zum Parsen von bash-Argumenten aufzurufen, verwenden Sie bash argparse ( https://github.com/mattbryson/bash-arg-parse ).

Dieselbe Antwort finden Sie hier: https://stackoverflow.com/questions/7069682/how-to-get-arguments-with-flags-in-bash-script/50181287#50181287

#!/bin/bash
echo "First arg: $1"
echo "Second arg: $2"
echo "Your First Argument was $1 & Second Argument was $2" 2> /dev/null

------------------------------------------------------------------------

./scriptname.sh value1 value2