Tweet

Estrutura de controle case … esac em Shell Scripting

A estrutura case … esac em Shell Scripting é usada para simplificar múltiplas verificações de valor em uma única variável. Ela funciona de maneira semelhante a uma estrutura switch em outras linguagens de programação, permitindo testar uma variável ou expressão contra diferentes padrões e executar comandos específicos com base nos resultados.

Sintaxe de case .. esac

A sintaxe da estrutura case é a seguinte:

case variável in
  padrão1)
    Comandos para o padrão1
    ;;
  padrão2)
    Comandos para o padrão2
    ;;
  *)
    Comandos para qualquer outro caso (opcional)
    ;;
esac

Onde:

• variável: A variável ou expressão a ser testada.
• padrão1, padrão2: Padrões que correspondem a diferentes valores possíveis da variável. Cada padrão termina com parênteses ).
• ;;: Indica o final dos comandos para cada padrão.
• *): Representa o “caso padrão” (opcional). Ele será executado se nenhum dos padrões anteriores corresponder.

Vejamos alguns exemplos de uso do condicional case em Shell Scripting.

Exemplo: Criar menu com comando case

Vamos criar um exemplo simples que exibe um menu e executa uma ação com base na escolha do usuário:

#!/bin/bash
echo "Escolha uma opção:"
echo "1) Exibir data"
echo "2) Exibir o diretório atual"
echo "3) Listar arquivos"
echo "4) Sair"
read -p "Digite sua escolha: " opcao
case $opcao in
  1)
    echo "Data atual: $(date)";;
  2)
    echo "Diretório atual: $(pwd)";;
  3)
    echo "Arquivos no diretório atual:"
    ls;;
  4)
    echo "Sair..."
    exit 0;;
  *)
    echo "Opção inválida!";;
esac

Neste exemplo:

• A estrutura case verifica o valor da variável opcao.
• Cada opção do menu (1, 2, 3, 4) corresponde a um bloco de comandos específico.
• O caso * serve para qualquer entrada que não corresponda a uma das opções definidas, exibindo “Opção inválida!”

Vejamos mais alguns exemplos de uso do case.

Usar múltiplos padrões em um único caso

O case permite agrupar múltiplos valores para um mesmo conjunto de comandos, separando os padrões com |.

Exemplo: Verificar vogais

Neste exemplo, o script verifica se uma letra fornecida pelo usuário é uma vogal ou não.

#!/bin/bash
read -p "Digite uma letra: " letra
case $letra in
  a|A|e|E|i|I|o|O|u|U)
    echo "Você digitou uma vogal.";;
  *)
    echo "A letra digitada não é uma vogal.";;
esac

Como usar padrões com expressões regulares no case

O case em Shell Scripting também permite o uso de expressões regulares para correspondência de padrões mais complexos.

Exemplo: Verificar um valor numérico digitado

Este exemplo verifica se a entrada do usuário é um número positivo, negativo ou zero.

#!/bin/bash
read -p "Digite um número: " numero
case $numero in
  ''|*[!0-9-]*) # Verifica se a entrada não é numérica; usar aspas simples no início dessa expressão regular
    echo "Entrada inválida. Por favor, digite um número.";;
  -*) # Verifica se o número é negativo
    echo "O número é negativo.";;
  0)
    echo "O número é zero.";;
  *)
    echo "O número é positivo.";;
esac

Como funciona a expressão regular usada?

Na expressão regular usada no exemplo, temos:

”: Duas aspas simples. Representa uma string vazia. Usado para capturar a situação em que o usuário não digita nada (a entrada é completamente vazia).

* antes de [!0-9-]: Permite que qualquer sequência de caracteres termine com pelo menos um caractere que não seja um número ou um sinal de menos.
Isso significa que, se houver qualquer caractere inválido na string, ela será capturada.

[!0-9-]: O […] é uma classe de caracteres, e ! no início significa negação dentro dessa classe. Já a parte [!0-9-] captura qualquer caractere que não seja um dígito (0-9) ou um sinal de menos (-).
Por exemplo, letras como a, b, ou símbolos como @, #, etc., correspondem a esse padrão.

*: (no final) Representa qualquer sequência de caracteres (incluindo nenhuma). Pode combinar desde uma string vazia até qualquer número de caracteres.

|: Representa o operador ou (alternativa lógica). Significa que o padrão será correspondido se a entrada for uma string vazia (”) ou se contiver caracteres que não sejam números ou um sinal de menos.

): Marca o final do padrão do case.

Excelente!  seguir trago alguns exercícios para você treinar mais o uso dos condicionais case..esac. As resoluções sugeridas se encontram logo após a listagem dos exercícios.

Exercícios com case … esac

1. Crie um script que exiba um menu com operações básicas (adição, subtração, multiplicação e divisão). O usuário escolhe a operação e fornece dois números. O script realiza a operação selecionada e exibe o resultado.

2. Escreva um script que peça um nome de arquivo ao usuário e exiba uma mensagem dizendo se é um diretório, um arquivo regular ou outro tipo de arquivo.

3. Crie um script que obtenha a hora atual e exiba uma saudação baseada na hora (por exemplo, “Bom dia”, “Boa tarde”, “Boa noite”).

4. Crie um script que permita ao usuário iniciar, parar ou reiniciar um serviço específico (como o serviço cron). O script deve perguntar ao usuário qual ação ele deseja realizar e executar o comando correspondente (sudo systemctl start|stop|restart cron).

5. Crie um script que peça ao usuário um nome de arquivo. Usando case, o script verifica a extensão do arquivo e exibe uma mensagem correspondente, como “Arquivo de imagem” para .jpg, “Arquivo de texto” para .txt, etc.

Resolução dos exercícios

Exercício 1: Menu de operações matemáticas

#!/bin/bash
echo "Escolha uma operação:"
echo "1) Adição"
echo "2) Subtração"
echo "3) Multiplicação"
echo "4) Divisão"
read -p "Digite sua escolha: " operacao
read -p "Digite o primeiro número: " num1
read -p "Digite o segundo número: " num2
case $operacao in
1)
  echo "Resultado: $((num1 + num2))";;
2)
  echo "Resultado: $((num1 - num2))";;
3)
  echo "Resultado: $((num1 * num2))";;
4)
  if [ "$num2" -eq 0 ]; then
    echo "Erro: Divisão por zero."
  else
    echo "Resultado: $((num1 / num2))"
  fi;;
*)
  echo "Operação inválida!";;
esac

Exercício 2: Verificar tipos de arquivos

#!/bin/bash
read -p "Digite o nome do arquivo: " arquivo
case $arquivo in
/*)
  if [ -d "$arquivo" ]; then
    echo "É um diretório."
  elif [ -f "$arquivo" ]; then
    echo "É um arquivo regular."
  else
    echo "Outro tipo de arquivo."
  fi;;
*)
  echo "Arquivo não encontrado.";;
esac

Exercício 3: Saudação baseada na hora do dia

#!/bin/bash
hora=$(date +%H)
case $hora in
  0[6-9]|1[0-1])
    echo "Bom dia!";;
  1[2-7])
    echo "Boa tarde!";;
  1[8-9]|2[0-3]|00|01|02|03|04|05)
    echo "Boa noite!";;
esac

Exercício 4: Menu de serviços do sistema

#!/bin/bash
echo "Escolha uma ação para o serviço cron:"
echo "1) Iniciar"
echo "2) Parar"
echo "3) Reiniciar"
read -p "Digite sua escolha: " acao
case $acao in
  1)
    sudo systemctl start cron
    echo "Serviço cron iniciado.";;
  2)
    sudo systemctl stop cron
    echo "Serviço cron parado.";;
  3)
    sudo systemctl restart cron
    echo "Serviço cron reiniciado.";;
  *)
    echo "Ação inválida!";;
esac

Exercício 5: Verificar extensão de arquivo

#!/bin/bash
read -p "Digite o nome do arquivo: " arquivo
case $arquivo in
  *.jpg|*.jpeg)
    echo "Arquivo de imagem.";;
  *.png)
    echo "Arquivo de imagem PNG.";;
  *.txt)
    echo "Arquivo de texto.";;
  *.sh)
    echo "Script de shell.";;
  *)
    echo "Extensão desconhecida.";;
esac

Conclusão

A estrutura case … esac permite simplificar a verificação de múltiplos valores e padrões, facilitando a criação de menus, verificações de entrada e controle de fluxo em scripts.

Usando o case, podemos tornar o código mais organizado e legível, além de lidar com diferentes opções de maneira eficiente.