web-dev-qa-db-fra.com

Comment passer un argument de ligne de commande dans un script Shell?

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

command-lineshell-scriptfunction
295
Paul

La commande Shell et tous les arguments de cette commande apparaissent sous la forme numérotées Variables Shell: $0 A la valeur de chaîne de la commande elle-même, quelque chose comme script, ./script, /home/user/bin/script Ou autre chose. Tous les arguments apparaissent sous la forme "$1", "$2", "$3" Et ainsi de suite. Le nombre d'arguments se trouve dans la variable Shell "$#".

Les manières courantes de gérer cela impliquent les commandes Shell getopts et shift. getopts ressemble beaucoup à la fonction de bibliothèque C getopt(). shift déplace la valeur de $2 vers $1, $3 vers $2, etc. $# Est décrémenté. Le code finit par regarder la valeur de "$1", En faisant des choses en utilisant un case… esac pour décider d'une action, puis en faisant un shift pour se déplacer $1 À l'argument suivant. Il n'a qu'à examiner $1, Et peut-être $#.

228
Bruce Ediger

Vous pouvez accéder aux arguments passés avec $n où n est le numéro de l'argument - 1, 2, 3, .... Vous passez 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
205
Kevin

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 nous appuyons pas sur 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 que les paramètres sont définis incorrectement. C'est très utile lorsque nous avons beaucoup de scripts avec différents paramètres à gérer. Cela fonctionne comme suit:

$ bash myscript -a "String A" -b "String B" -c "String C"
String A
String B
String C

$ bash myscript -a "String A" -c "String C" -b "String B"
String A
String B
String C

$ bash 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

$ bash 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
34
Rafael Muynarsk
$/shellscriptname.sh argument1 argument2 argument3

Vous pouvez également passer la sortie d'un script Shell comme argument à un autre script Shell.

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

Dans le script Shell, vous pouvez accéder aux arguments avec des nombres comme $1 pour le premier argument et $2 pour le deuxième argument et ainsi de suite.

Plus d'informations sur les arguments Shell

32
Balaswamy vaddeman

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. Ensuite, utilisez

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

pour contrôler le flux. Je n'embrasse généralement pas les getopts si un case ... esac suffira.

21
user400344
./myscript myargument

myargument devient $1 à l'intérieur myscript.

14
vimdude

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 manuel Shell (sh) à http://heirloom.sourceforge.net/sh/sh.1.html

8
FireInTheSky

Si vous connaissez Python argparse, et cela ne vous dérange pas 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

1
Linh
#!/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
0
Yogesh

Ce qui suit est le mien:

#!/bin/bash 
echo 'First arg:' $1 
echo 'Second arg:' $2

Le nom du shell est para_script.sh

Exécutez-le ensuite: ./para_script.sh hello world

0
Newt