Recuperando argumentos passados para um script shell (Linux/Bash)

Dominar a arte de manipular argumentos de linha de comando é uma habilidade essencial para qualquer entusiasta de scripts. Neste post leve, porém sério, vamos desvendar juntos os mistérios de como capturar esses argumentos em Bash, tornando seus scripts mais adaptáveis e poderosos. Seja você um veterano da linha de comando ou um novato curioso, prepare-se para adicionar mais uma ferramenta ao seu cinto de utilidades de programação.

Uma parte importante de ser fazer um script é conseguir pegar os argumentos que são passados via linha de comando. Neste post vou mostrar como recuperar estes argumentos.

Conseguir as informações passadas via linha de comando é bem simples. Considere o exemplo abaixo:

script.sh foo bar "bacon bacon bacon" 42 12.84

Neste exemplo, foram passados os seguintes argumentos para o script:

1. foo
2. bar
3. bacon bacon bacon
4. 42
5. 12.84

Ok, mas como recuperar estes valores dentro do script?

Recuperando argumentos passados via linha de comando

Simples, basta utilizar $1 para o primeiro argumento, $2 para o segundo, $3 para o terceiro, $4 para o quarto e $5 para o quinto. A variável $0 ($ zero) sempre armazena o nome do script que está sendo executado.

Um exemplo disso:

#!/bin/bash

echo "Script: $0"
echo "Arg 01: $1"
echo "Arg 02: $2"
echo "Arg 03: $3"
echo "Arg 04: $4"
echo "Arg 05: $5"

O resultado da execução de um script com o código acima e a linha que comando que estamos utilizando como exemplo teria o seguinte resultado:

Script: ./script.sh
Arg 01: foo
Arg 02: bar
Arg 03: bacon bacon bacon
Arg 04: 42
Arg 05: 12.84

Recuperando a quantidade de argumentos

Neste caso, eu ja sabia quantos argumentos estavam sendo passados, mas se você quiser ter este número, basta buscar o valor da variável $#. Atualizando nosso script de teste para mostrar o número de argumentos:

#!/bin/bash

echo "Qty args: $#"
echo "Script: $0"
echo "Arg 01: $1"
echo "Arg 02: $2"
echo "Arg 03: $3"
echo "Arg 04: $4"
echo "Arg 05: $5"

A diferença é que adicionei a linha: echo “Qty args: $#”

Ao executarmos o este script novamente, com a mesma linha de comando, teremos o seguinte resultado:

Qty args: 5
Script: ./a.sh
Arg 01: foo
Arg 02: bar
Arg 03: bacon bacon bacon
Arg 04: 42
Arg 05: 12.84

Fazendo uma iteração entre os argumentos

Para deixar as coisas mais dinâmicas um pouco, vou mostrar como fazer um loop pelos argumentos passados via linha de comando…

#!/bin/bash
i=0
echo "Qty args: $#"
echo "Script: $0"

for arg in "$@"
do
    i=$((i+1))
    echo "Arg $i: $arg"
done

No script acima, os dois primeiros comandos echo mostram (respectivamente) a quantidade de argumentos e o nome do script.

Na sequencia, faço um loop pelo vetor que armazena os argumentos passados. Este vetor é referenciado pela variável $@.

A variável i foi criada apenas para mostrar o número da variável que estamos lendo.

Verificando uma flag na linha de comando

Até este momento, já mostrei como ler os argumentos que são passados, como verificar a quantidade de argumentos e como fazer uma iteração pelos argumentos. Agora vou mostrar uma aplicação um pouco mais real deste procedimento. Vou alterar o script criado anteriormente para procurar o argumento “-flag”. Quando executado, o script vai informar se encontrou ou não o argumento -flag.

Script alterado:

#!/bin/bash

echo "Qty args: $#"
echo "Script: $0"
found=false

for arg in "$@"
do
  if [[ "$arg" = "-flag" ]]; then
    found=true
    break
  fi
done

if $found; then
    echo "Found!"
else
    echo "Not found!"
fi

No exemplo acima, a lógica do loop é a mesma. A diferença é que inclui uma verificação se o argumento que está sendo lido naquela interação do loop ("$arg") é igual a “-flag”.

Espero ter ajudado.