Comment puis-je passer un argument de ligne de commande dans un script shell?

Je sais que les scripts de shell exécutent des commandes comme si elles étaient exécutées à l'invite de commande. J'aimerais pouvoir exécuter des scripts de shell comme s'il s'agissait de fonctions ... C'est-à-dire prendre une valeur d'entrée ou une chaîne dans le script. Comment puis-je aborder cela?

La commande shell et des arguments à cette commande apparaissent comme numérotées variables shell: $0a la valeur de chaîne de la commande elle - même, quelque chose comme script, ./script, /home/user/bin/scriptou autre chose. Tous les arguments apparaissent comme "$1", "$2", "$3"et ainsi de suite. Le nombre d'arguments est dans la variable shell "$#".

Les moyens habituels de gérer cela impliquent des commandes shell getoptset shift. getoptsressemble beaucoup à la getopt()fonction de bibliothèque C. shiftdéplace la valeur de $2to $1, $3to $2, etc. $#se décrémente. Le code finit par regarder la valeur de "$1", faire les choses en utilisant un case… esacpour décider d'une action, puis en faisant shiftpasser $1à l'argument suivant. Il n’ya qu’à examiner $1, et peut-être $#.

Vous pouvez accéder aux arguments passés avec $noù nest le numéro de l'argument - 1, 2, 3, .... Vous transmettez les arguments comme vous le feriez avec n'importe quelle autre commande.

$ 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 

Vous pouvez également transmettre la sortie d'un script shell en tant qu'argument à un autre script shell.

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

Dans un script shell, vous pouvez accéder aux arguments avec des nombres comme $1pour le premier argument et $2pour le second argument, etc.

Plus sur les arguments du shell

La forme

$ ./script.sh "$@" 

est le plus pratique pour argv. Le délimiteur arg est un espace, mais peut être modifié. Je ne me souviens pas à quel point Puis utiliser

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

pour contrôler le flux. Je n'embrasse généralement pas getopts si case ... esaccela suffit.

Sur un script bash, j'aime personnellement utiliser le script suivant pour définir les paramètres:

#!/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"

Avec cette structure, nous ne dépendons pas de l'ordre des paramètres, car nous définissons une lettre clé pour chacun d'eux. De plus, la fonction d’aide sera imprimée toutes les fois où les paramètres sont définis de manière erronée. C'est très utile lorsque nous avons beaucoup de scripts avec différents paramètres à gérer. Cela fonctionne comme suit:

$ ./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

myargumentdevient à l' $1intérieur myscript.

Dans le script shell; il devient le nom de variable $ 1. Le deuxième mot devient le nom de variable $ 2 et ainsi de suite.

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

Plus peut-être trouvé dans le shell (sh) manual à http://heirloom.sourceforge.net/sh/sh.1.html

Si vous connaissez Python argparse, et que cela vous est égal d'appeler python pour analyser les arguments bash, utilisez bash argparse ( https://github.com/mattbryson/bash-arg-parse ),

Voir la même réponse ici: 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