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

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?

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 case… esacpara decidir sobre uma ação e depois fazer um shiftpara passar $1para o próximo argumento. Só tem que examinar $1, e talvez $#.

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

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

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.

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

./myscript myargument

myargumenttorna-se $1dentro myscript.

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

Se você conhece Python argparse e não se importa de chamar python para analisar argumentos bash, use bash argparse ( https://github.com/mattbryson/bash-arg-parse ),

Veja a mesma resposta aqui: 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