Passagem de Argumentos para o Script

Introdução

Na programação Shell, a capacidade de passar argumentos para um script é um recurso fundamental e poderoso. Isso permite que os scripts sejam mais flexíveis e reutilizáveis ao aceitarem entradas diretamente da linha de comando. Este laboratório guiará você pelo processo de criação de um script Shell capaz de receber e utilizar argumentos. Você aprenderá como acessar esses argumentos dentro do seu script, lidar com múltiplos parâmetros e usar variáveis especiais para processá-los de forma eficiente.

Criar um novo arquivo de script

Vamos começar criando um novo arquivo de script. Usaremos o WebIDE (VS Code) para este laboratório.

1. Abra o WebIDE, caso ainda não esteja aberto.
2. No explorador de arquivos à esquerda, navegue até o diretório /home/labex/project.
3. Clique com o botão direito no explorador de arquivos e selecione "New File".
4. Nomeie o novo arquivo como arguments.sh.

Agora que criamos o arquivo, vamos adicionar a estrutura básica do nosso script:

#!/bin/bash

## Your code will go here

A primeira linha é chamada de "shebang" ou "hashbang". Ela informa ao sistema qual interpretador deve ser usado para executar o script. Neste caso, estamos usando o bash.

Para iniciantes: A linha shebang é importante porque permite que você execute o script diretamente (como ./arguments.sh) em vez de ter que digitar bash arguments.sh toda vez. É um pequeno detalhe, mas torna o uso dos seus scripts muito mais conveniente.

Acessar argumentos do script

Agora, vamos modificar nosso script para acessar e exibir os argumentos passados para ele. No Shell script, variáveis especiais são usadas para acessar os argumentos da linha de comando:

• $0 representa o nome do próprio script
• $1, $2, $3, etc., representam o primeiro, segundo e terceiro argumentos, sucessivamente

Adicione o seguinte código ao seu arquivo arguments.sh:

#!/bin/bash

echo "Script name: $0"
echo "First argument: $1"
echo "Second argument: $2"
echo "Third argument: $3"

Este script exibirá o nome do arquivo e os três primeiros argumentos fornecidos.

Para iniciantes:

• O símbolo $ é usado para referenciar variáveis no bash.
• $0, $1, $2, etc., são variáveis especiais que o bash define automaticamente para você quando você executa um script com argumentos.
• Se você executar o script sem nenhum argumento, $1, $2 e $3 ficarão vazios, mas o script ainda assim será executado sem erros.

Tornar o script executável

Antes de podermos rodar nosso script, precisamos torná-lo executável. Isso é feito usando o comando chmod. No terminal, navegue até o diretório do projeto e execute o seguinte comando:

cd /home/labex/project
chmod +x arguments.sh

O comando chmod +x adiciona permissões de execução ao arquivo, permitindo que ele seja rodado como um programa.

Para iniciantes:

• chmod significa "change mode" (mudar modo). É usado para alterar as permissões de um arquivo ou diretório.
• A opção +x adiciona a permissão de execução. Isso é necessário para que o bash consiga rodar o arquivo como um script.
• Se você esquecer este passo, receberá um erro de "permissão negada" (permission denied) ao tentar executar seu script.

Executar o script com argumentos

Agora que nosso script é executável, vamos rodá-lo com alguns argumentos. No terminal, execute o seguinte comando:

./arguments.sh hello world example

Você deverá ver uma saída semelhante a esta:

Script name: ./arguments.sh
First argument: hello
Second argument: world
Third argument: example

Esta saída mostra que nosso script acessou e exibiu com sucesso os argumentos da linha de comando.

Para iniciantes:

• O ./ antes do nome do script diz ao bash para procurar o arquivo no diretório atual.
• Cada palavra após o nome do script torna-se um argumento separado. Neste caso, "hello" é o primeiro, "world" o segundo e "example" o terceiro.
• Se você quiser passar um argumento que contenha espaços, precisa usar aspas, assim: ./arguments.sh "hello world" example

Lidar com a quantidade de argumentos

Vamos modificar nosso script para lidar com diferentes quantidades de argumentos. Usaremos a variável especial $#, que armazena o número total de argumentos passados para o script.

Atualize seu arquivo arguments.sh com o seguinte conteúdo:

#!/bin/bash

if [ $## -eq 0 ]; then
  echo "No arguments provided."
elif [ $## -eq 1 ]; then
  echo "One argument provided: $1"
elif [ $## -eq 2 ]; then
  echo "Two arguments provided: $1 and $2"
else
  echo "More than two arguments provided:"
  echo "First argument: $1"
  echo "Second argument: $2"
  echo "Third argument: $3"
  echo "Total number of arguments: $#"
fi

Este script utiliza estruturas condicionais para tratar diferentes cenários baseados no número de argumentos.

Para iniciantes:

• $# é uma variável especial que contém a contagem de argumentos passados.
• [ $## -eq 0 ] é uma condição que verifica se o número de argumentos é igual a 0.
• elif é uma abreviação de "else if". Permite verificar múltiplas condições em sequência.
• O operador -eq significa "equal to" (igual a). Existem outros operadores como -lt (menor que), -gt (maior que), etc.

Testar o script atualizado

Agora, vamos testar nosso script atualizado com diferentes quantidades de argumentos:

./arguments.sh
./arguments.sh one
./arguments.sh one two
./arguments.sh one two three four

Você verá saídas diferentes dependendo de quantos argumentos foram fornecidos.

Para iniciantes:

• Executar o script sem argumentos (./arguments.sh) ativará a primeira condição do nosso código.
• Cada comando subsequente adiciona mais argumentos, demonstrando como o script processa cada caso.
• Observe como o comportamento do script muda dinamicamente. Esse tipo de flexibilidade é extremamente útil em scripts do mundo real.

Iterar por todos os argumentos

Por fim, vamos modificar nosso script para percorrer todos os argumentos fornecidos usando a variável especial $@, que representa a lista completa de argumentos da linha de comando.

Atualize seu arquivo arguments.sh com o seguinte conteúdo:

#!/bin/bash

echo "Total number of arguments: $#"
echo "All arguments:"

count=1
for arg in "$@"; do
  echo "Argument $count: $arg"
  count=$((count + 1))
done

Este script utiliza um laço for para iterar por todos os argumentos e exibi-los junto com sua posição.

Para iniciantes:

• $@ é uma variável especial que contém todos os argumentos passados para o script como uma lista.
• O laço for é usado para repetir ações sobre uma lista de itens.
• $((count + 1)) é uma expansão aritmética no bash, usada para incrementar o valor da variável count.
• Este script funcionará com qualquer quantidade de argumentos, tornando-o muito mais versátil que as versões anteriores.

Testar o script final

Vamos testar nossa versão final com vários argumentos:

./arguments.sh apple banana cherry date

Você deverá ver uma saída similar a esta:

Total number of arguments: 4
All arguments:
Argument 1: apple
Argument 2: banana
Argument 3: cherry
Argument 4: date

Isso demonstra que nosso script agora pode lidar com qualquer número de argumentos e listar todos eles.

Para iniciantes:

• Esta versão final é muito mais flexível.
• Ela lida com qualquer quantidade, de zero a muitos argumentos.
• O script agora numera cada argumento, o que é muito útil em automações complexas.
• Tente rodar o script com diferentes combinações para observar como ele se comporta.

Resumo

Neste laboratório, você aprendeu como criar um script Shell capaz de aceitar e processar argumentos de linha de comando. Exploramos diversos conceitos fundamentais:

1. Criação e atribuição de permissão de execução a um script.
2. Acesso a argumentos individuais usando variáveis especiais ($1, $2, etc.).
3. Uso da variável $## para determinar a quantidade de argumentos.
4. Implementação de lógica condicional para tratar diferentes cenários de entrada.
5. Uso da variável $@ para iterar através de todos os argumentos fornecidos.

Essas habilidades são a base do Shell scripting e permitirão que você crie scripts mais poderosos e adaptáveis a diferentes entradas. À medida que você evoluir, verá que a manipulação de argumentos é crucial para criar ferramentas reutilizáveis em administração de sistemas e automação de tarefas.