Como posso passar um argumento de linha de comando para um shell script?

243

Eu sei que scripts de shell apenas executam comandos como se fossem executados no prompt de comando. Eu gostaria de poder executar scripts de shell como se fossem funções ... Ou seja, inserir um valor de entrada ou string no script. Como me aproximo de fazer isso?

Paulo
fonte

Respostas:

199

O comando shell e quaisquer argumentos para esse comando aparecer como numeradas variáveis do shell: $0tem o valor da cadeia do próprio comando, algo como script, ./script, /home/user/bin/scriptou o que quer. Quaisquer argumentos aparecer como "$1", "$2", "$3"e assim por diante. A contagem de argumentos está na variável shell "$#".

Maneiras comuns de lidar com isso envolvem comandos getoptse shell shift. getoptsé muito parecido com a getopt()função da biblioteca C. shiftmove o valor de $2para $1, $3para $2e assim por diante; $#é diminuído. O código acaba analisando o valor de "$1", fazer as coisas usando um caseesacpara decidir sobre uma ação e depois fazer um shiftpara passar $1para o próximo argumento. Só tem que examinar $1, e talvez $#.

Bruce Ediger
fonte
6
o C getopt()é um padrão extremamente estabelecido, mas o getoptexecutável não é o mesmo na distribuição / plataforma. Agora sou um getoptsusuário totalmente convertido , pois é um padrão POSIX. Ele funciona muito bem com dashtambém, que é o meu shell script de preferência
JM Becker
165

Você pode acessar os argumentos passados ​​com $nonde nestá o número do argumento - 1, 2, 3, .... Você passa os argumentos como faria com qualquer outro comando.

$ cat myscript
#!/bin/bash
echo "First arg: $1"
echo "Second arg: $2"
$ ./myscript hello world
First arg: hello
Second arg: world
Kevin
fonte
27
$/shellscriptname.sh argument1 argument2 argument3 

Você também pode passar a saída de um script de shell como argumento para outro script de shell.

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

No shell script, você pode acessar argumentos com números como $1para o primeiro argumento e $2para o segundo argumento e assim por diante.

Mais sobre argumentos de shell

Balaswamy vaddeman
fonte
18

A forma

$ ./script.sh "$@" 

é o mais conveniente para argv. O delimitador de arg é um espaço em branco, mas pode ser alterado. Não me lembro de como é improvável Então use

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

para controlar o fluxo. Eu geralmente não adoro getopts se a case ... esacfor suficiente.

user400344
fonte
14

Em um script bash, eu pessoalmente gosto de usar o seguinte script para definir parâmetros:

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

Com essa estrutura, não confiamos na ordem dos parâmetros, pois estamos definindo uma letra-chave para cada um deles. Além disso, a função de ajuda será impressa sempre que os parâmetros forem definidos incorretamente. É muito útil quando temos muitos scripts com parâmetros diferentes para lidar. Funciona da seguinte forma:

$ ./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
Rafael Muynarsk
fonte
13
./myscript myargument

myargumenttorna-se $1dentro myscript.

vimdude
fonte
5

No script shell; torna-se o nome da variável $ 1. A segunda palavra se torna o nome da variável $ 2 e assim por diante.

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

Talvez mais seja encontrado no manual do shell (sh) em http://heirloom.sourceforge.net/sh/sh.1.html

Fogo no céu
fonte
2
bem-vindo à U&L, isso dificilmente adiciona algo à resposta já dada.
Archemar 20/09/17
0
#!/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
Yogesh
fonte
3
1) desnecessário 2> /dev/null, 2) não adiciona nada às respostas existentes.
xenoid 28/01