Um dos comandos de controle de fluxo mais usados é certamente o if, que é baseado na lógica "se acontecer isso, irei fazer isso. Se não, irei fazer aquilo". Vamos dar um exemplo:

#!/bin/bash
if [ -e $linux ]
then
   echo 'A variável $linux existe.'
else
   echo 'A variável $linux não existe.'
fi

O que este pedaço de código faz? O if testa a seguinte expressão: Se a variável $linux existir, então (then) ele diz que que existe com o echo, se não (else), ele diz que não existe. O operador -e que usei é pré-definido e você pode encontrar a listagem dos operadores na tabela:

Vamos para alguns exemplos, assim entendemos melhor o uso:

#!/bin/bash
if [ -z $naoexisto ]
then
   echo 'A variável $naoexisto realmente não existe! Incrível.'
   echo -n 'Criando... '
   naoexisto="agoraeuexisto"
   echo 'feito.'
else
   echo 'Oops! Não era pra você existir!'
fi

#!/bin/bash
a=1
b=2

if [ $a -lt $b ]
then
   echo '$a é menor que $b!'
elif [ $a -gt $b ]
then
   echo '$a é maior que $b!'
elif [ $a -eq $b ]
then
   echo '$a é igual a $b!'
fi

#!/bin/bash
if [ -d "/etc" ]
then
   echo '/etc existe e é um diretório!'
   if [ -f "/etc/passwd" ]
   then
      echo '/etc/passwd existe e é um arquivo!'
   fi
else
   echo '/etc não existe :('
fi

Note nos exemplos acima que citamos um "comando" não visto antes: o elif, que é uma combinação de else e if. Ao invés de fechar o if para criar outro, usamos o elif para testar uma expressão no mesmo comando if.

Existem inúmeros comandos no Linux e para explicar todos, teríamos de publicar um verdadeiro livro. Você pode usar livremente qualquer comando texto disponível no seu Linux. Também se quiser, há muitas descrições na página de manual do bash, que pode ser acessada com o comando man bash.

Na tabela a seguir, você pode encontrar uma listagem de comandos para usar em sua shell script:

E assim seja, crie seus próprios scripts e facilite de uma vez só parte de sua vida no Linux!

O case é para controle de fluxo, tal como é o if. Mas enquanto o if testa expressões não exatas, o case vai agir de acordo com os resultados exatos. Vejamos um exemplo:

case $1 in
   parametro1) comando1 ; comando2 ;;
   parametro2) comando3 ; comando4 ;;
   *) echo "Você tem de entrar com um parâmetro válido" ;;
esac

Aqui aconteceu o seguinte: o case leu a variável $1 (que é o primeiro parâmetro passado para o programa) e comparou com valores exatos. Se a variável $1 for igual à "parametro1", então o programa executará o comando1 e o comando2; se for igual à "parametro2", executará o comando3 e o comando4 e assim em diante. A última opção (*), é uma opção padrão do case, ou seja, se o parâmetro passado não for igual a nenhuma das outras opções anteriores, esse comando será executado automaticamente.

Você pode ver que, com o case fica muito mais fácil criar uma espécie de "menu" para o shell script do que com o if. Vamos demonstrar a mesma função anterior, mas agora usando o if:

if [ -z $1 ]; then
   echo "Você tem de entrar com um parâmetro válido"
   exit
elif [ $1 = "parametro1" ]; then
   comando1
   comando2
elif [ $1 = "parametro2" ]; then
   comando3
   comando4
else
   echo "Você tem de entrar com um parâmetro válido"
fi

Veja a diferença. É muito mais prático usar o case! A vantagem do if é que ele pode testar várias expressões que o case não pode. O case é mais prático, mas o if pode substituí-lo e ainda abrange mais funções. Note que, no exemplo com o if, citamos um "comando" não visto antes: o elif - que é uma combinação de else e if. Ao invés de fechar o if para criar outro, usamos o elif para testar uma expressão no mesmo comando if.

O laço for vai substituindo uma variável por um valor e vai executando os comandos pedidos. Veja o exemplo:

for i in *
do
   cp $i $i.backup
   mv $i.backup /usr/backup
done

Primeiramente o laço for atribuiu o valor de retorno do comando "*" (que é equivalente a um ls sem nenhum parâmetro) para a variável $i, depois executou o bloco de comandos. Em seguida ele atribui outro valor do comando "*" para a variável $1 e reexecutou os comandos. Isso se repete até que não sobrem valores de retorno do comando "*". Outro exemplo:

for original in *; do
   resultado=`echo $original |
              tr '[:upper:]' '[:lower:]'`
   if [ ! -e $resultado ]; then
      mv $original $resultado
   fi
done

Aqui, o que ocorre é a transformação de letras maiúsculas para minúsculas. Para cada arquivo que o laço lê, uma variável chamada $resultado irá conter o arquivo em letras minúsculas. Para transformar em letras minúsculas, usei o comando tr. Caso não exista um arquivo igual e com letras minúsculas, o arquivo é renomeado para o valor da variável $resultado, de mesmo nome, mas com letras minúsculas.

Como os exemplos ilustram, o laço for pode ser bem útil no tratamento de múltiplos arquivos. Você pode deixá-los todos com letras minúsculas ou maiúsculas sem precisar renomear cada um manualmente, pode organizar dados, fazer backup, entre outras coisas.

O while testa continuamente uma expressão, até que ela se torne falsa. Exemplo:

variavel="valor"
while [ $variavel = "valor" ]; do
   comando1
   comando2
done

O que acontece aqui é o seguinte: enquanto a "$variavel" for igual a "valor", o while ficará executando os comandos 1 e 2, até que a "$variavel" não seja mais igual a "valor". Se no bloco dos comandos a "$variavel" mudasse, o while iria parar de executar os comandos quando chegasse em done, pois agora a expressão $variavel = "valor" não seria mais verdadeira.

Tem as mesmas características do while, a única diferença é que ele faz o contrário. Veja o exemplo abaixo:

variavel="naovalor"
until [ $variavel = "valor" ]; do
   comando1
   comando2
done

Ao invés de executar o bloco de comandos (comando1 e comando2) até que a expressão se torne falsa, o until testa a expressão e executa o bloco de comandos até que a expressão se torne verdadeira. No exemplo, o bloco de comandos será executado desde que a expressão $variavel = "valor" não seja verdadeira. Se no bloco de comandos a variável for definida como "valor", o until pára de executar os comandos quando chega ao done.

Vejamos um exemplo para o until que, sintaticamente invertido, serve para o while também:

var=1
count=0
until [ $var = "0" ]; do
   comando1
   comando2
   if [ $count = 9 ]; then
      var=0
   fi
   count=`expr $count + 1`
done

Primeiro, atribuímos à variável "$var" o valor "1". A variável "$count" será uma contagem para quantas vezes quisermos executar o bloco de comandos. O until executa os comandos 1 e 2, enquanto a variável "$var" for igual a "0". Então usamos um if para atribuir o valor 0 para a variável "$var", se a variável "$count" for igual a 9. Se a variável "$count" não for igual a 0, soma-se 1 a ela. Isso cria um laço que executa o comando 10 vezes, porque cada vez que o comando do bloco de comandos é executado, soma-se 1 à variável "$count" e quando chega em 9, a variável "$var" é igualada a zero, quebrando assim o laço until.