Shell Script Básico

Shell script - Bash

Estrutura geral de um script Shell

Os scripts permitem construir esquemas de execução complexos a partir dos comandos básicos do shell. A forma mais elementar de arquivo de script é apenas um conjunto de comandos em um arquivo texto, com permissões de execução habilitadas.

Parâmetros de entrada

Os argumentos da linha de comando são passados para o shell através da variável local $argv. Os campos individuais dessa variável podem ser acessados como em uma variável local qualquer. Além disso, uma série de atalhos é definida para facilitar o acesso a esses parâmetros:

• $0 : o nome do script
• $n : o n-ésimo argumento da linha de comando
• $* : todos os argumentos da linha de comando
• $# : número de argumentos
• $? : status do último comando executado (status <> 0 indica erro)
• $$ : número de processo (PID) do shell que executa o script

Exemplo através do script listaparams:

#!/bin/bash 
# exemplo de uso dos parâmetros de entrada 
echo "Nome do script : $0"
echo "Primeiro parâmetro : $1" 
echo "Todos os parâmetros : $*" 
echo "Numero de parametros : $#" 
echo "Numero deste processo : $$" 
exit 0

Chamando o script acima com alguns parâmetros se obtém a seguinte resposta:

~> listaparams banana tomate pessego melao pera uva 
Nome do script : listaparams 
Primeiro parâmetro : banana 
Todos os parâmetros : banana tomate pessego melao pera uva 
Numero de parametros : 6 
Numero deste processo : 2215 
~>

Controle de fluxo

Existem diversos construtores de controle de fluxo que podem ser usados em scripts BASH-Shell. Os principais são descritos a seguir.

Condições

Como na maioria das linguagens, no shell Bash, testes de condições são realizados por estruturas do tipo if-then-else. As condições testadas são os status de saída da execução de comandos (o valor inteiro retornado pela chamada de sistema exit() do comando). Caso o status seja zero (0), a condição é considerada verdadeira:

if cmp $file1 $file2 >/dev/null   # testa o status do comando cmp
then
   echo "os arquivos são iguais"
else
   echo "os arquivos são distintos"
fi

Essa lógica “ao contrário” pode causar uma certa confusão aos iniciantes. Assim, para simplificar a programação de scripts, é definido um operador test condition, que também pode ser representado por [ condition ] e retorna zero (0) se a condição testada for verdadeira:

if [ $n1 -lt $n2 ]          # $n1 é menor que $n2?
then
   echo "$n1 é menor que $n2"
fi

if test $n1 -lt $n2         # $n1 é menor que $n2?
then
   echo "$n1 é menor que $n2"
fi

Os principais operadores de teste disponíveis são:
Operador if-then

if comando
then
   ... 
fi

# testa o status do comando cmp
if cmp file1 file2 >/dev/null
then
   echo "Os arquivos são iguais"
fi

Operador if-then-else

if comando
then
   ... 
else
   ...
fi

# testa a existência de $file1
if [ -e "$file1" ]
then
   echo "$file1 existe"
else
   echo "$file1 não existe"
fi

Operador if-then-elif-else

if comando 1
then
   ...
elif comando 2
then
   ...
else
   ...
fi

# compara as variáveis $n1 e $n2
if [ $n1 -lt $n2 ]
then
   echo "$n1 < $n2"
elif [ $n1 -gt $n2 ]
then
   echo "$n1 > $n2"
else
   echo "$n1 = $n2"
fi

Operador case

case variável in 
   "string1") 
      ... 
      break;; 
   "string2") 
      ... 
      break;; 
   *): 
      ... 
      break;; 
esac

case $opt in
   "-c") complete=1 ;;
   "-s") 
         short=1 ;
         name="" ;;
   *)
         echo "opção $opt desconhecida" ;
         exit 1 ;;
esac    

Os principais tipos de teste disponíveis são:

• Comparações entre números
  • -eq : igual a
  • -ne : diferente de
  • -gt : maior que
  • -ge : maior ou igual a
  • -lt : menor que
  • -le : menor ou igual a
  • -a : AND binário (bit a bit)
  • -o : OR binário (bit a bit)
• Comparações entre strings usando []
  • = : igual a
  • != : diferente de
  • -z : string de tamanho zero
• Comparações entre strings usando [[]]
  • ⇐ : menor ou igual a (lexicográfico)
  • >= : maior ou igual a (lexicográfico)
• Associações entre condições
  • && : AND lógico
  • || : OR lógico

Os operadores de teste em arquivos permitem verificar propriedades de entradas no sistema de arquivos. Eles são usados na forma -op, onde op corresponde ao teste desejado. Os principais testes são:

• e : a entrada existe
• r : a entrada pode ser lida
• w : a entrada pode ser escrita
• O : o usuário é o proprietário da entrada
• s : tem tamanho maior que zero
• f : é um arquivo normal
• d : é um diretório
• L : é um link simbólico
• b : é um dispositivo orientado a bloco
• c : é um dispositivo orientado a caracatere
• p : é um named pipe (fifo)
• S : é um socket special file
• u : tem o bit SUID habilitado
• g : tem o bit SGID habilitado
• G : grupo da entrada é o mesmo do proprietário
• k : o stick bit está habilitado
• x : a entrada pode ser executada
• nt : Verifica se um arquivo é mais novo que outro
• ot : Verifica se um arquivo é mais velho que outro
• ef : Verifica se é o mesmo arquivo (link)

Eis um exemplo de uso de testes em arquivos:

arquivo='/etc/passwd' 

if [ -e $arquivo ] 
then 
   if [ -f $arquivo ] 
   then 
      if [ -r $arquivo ] 
      then 
         source $arquivo 
      else 
         echo "Nao posso ler o arquivo $arquivo"
      fi 
   else 
      echo "$arquivo não é um arquivo normal"
   fi 
else 
   echo "$arquivo não existe"
fi

Laços

Laço for

for variável in lista de valores
do 
   ... 
done

for i in *.c
do
   echo "compilando $i"
   cc -c $i
done

Laço while

while condição
do 
   ... 
done

i=0
while [ $i -lt 10 ]
do
   echo $i
   let i++
done

Operador select

select variável in lista de valores
do 
   ...
done

select f in "abacate" "pera" "uva" "banana" "morango"
do
   echo "Escolheu $f"
done

Além das estruturas acima, algumas outras podem ser usadas para executar comandos em situações específicas:

• `comando` : substitui a expressão entre crases pelo resultado (stdout) da execução do comando. Por exemplo, a linha de comando abaixo coloca na variável arqs os nomes de arquivos retornados pelo comando find:

arqs=`find /etc -type f -iname '???'`

• comando1; comando2; comando3 : executa seqüencialmente os comandos indicados

Operadores aritméticos

Variáveis contendo números inteiros podem ser usadas em expressões aritméticas e lógicas. A atribuição do resultado de uma expressão aritmética a uma variável pode ser feita de diversas formas. Por exemplo, as três expressões a seguir têm o mesmo efeito:

i=$((j + k))

let i=j+k

i=`expr $j + $k`

Os principais operadores aritméticos disponíveis são:

• + - * / : aritmética básica
• ** : potenciação
• % : módulo (resto)
• += -= *= /= %= : aritmética e atribuição (como em C)
• « » : deslocamento de bits
• «= »= : deslocamento e atribuição
• & | : AND e OR binários
• &= |= : AND e OR binários com atribuição
• ! : NOT binário
• ^ : XOR binário
• && || : AND e OR lógicos

 
OBS:

#!/bin/bash --noprofile
# A opção --noprofile inibe a leitura dos arquivos de inicialização
# do shell, tornando o lançamento do script muito mais rápido. 

--

Fonte: Shell Script