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:

1script.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:

1#!/bin/bash
2
3echo "Script: $0"
4echo "Arg 01: $1"
5echo "Arg 02: $2"
6echo "Arg 03: $3"
7echo "Arg 04: $4"
8echo "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:

1Script: ./script.sh
2Arg 01: foo
3Arg 02: bar
4Arg 03: bacon bacon bacon
5Arg 04: 42
6Arg 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:

1#!/bin/bash
2
3echo "Qty args: $#"
4echo "Script: $0"
5echo "Arg 01: $1"
6echo "Arg 02: $2"
7echo "Arg 03: $3"
8echo "Arg 04: $4"
9echo "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:

1Qty args: 5
2Script: ./a.sh
3Arg 01: foo
4Arg 02: bar
5Arg 03: bacon bacon bacon
6Arg 04: 42
7Arg 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…

 1#!/bin/bash
 2i=0
 3echo "Qty args: $#"
 4echo "Script: $0"
 5
 6for arg in "$@"
 7do
 8    i=$((i+1))
 9    echo "Arg $i: $arg"
10done

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:

 1#!/bin/bash
 2
 3echo "Qty args: $#"
 4echo "Script: $0"
 5found=false
 6
 7for arg in "$@"
 8do
 9  if [[ "$arg" = "-flag" ]]; then
10    found=true
11    break
12  fi
13done
14
15if $found; then
16    echo "Found!"
17else
18    echo "Not found!"
19fi

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.