Em Shell Scripting, os laços de repetição são estruturas que permitem executar uma série de comandos várias vezes. Os loops ajudam a automatizar tarefas repetitivas, iterando sobre listas, variáveis, comandos e arquivos. O Bash oferece algumas estruturas de repetição essenciais: for, while, e until.

Vamos explorar cada uma, com exemplos práticos e exercícios ao final.

O laço for em shell scripting

O laço for é usado para percorrer uma lista de itens, como um conjunto de números, strings ou até mesmo arquivos. Ele executa o conjunto de comandos uma vez para cada item na lista.

Sintaxe básica do laço for

for item in lista; do
   Comandos a serem executados
done

Exemplo 1: Laço for simples

Esse exemplo exibe uma mensagem para cada nome da lista.

#!/bin/bash
for nome in Fábio Marcos Bruno Robson; do
  echo "Olá, $nome!"
done

Saída:

Olá, Fábio!
Olá, Marcos!
Olá, Bruno!
Olá Robson!

Exemplo 2: Laço for com intervalo de números

Podemos definir um intervalo de números e iterar sobre ele:

#!/bin/bash
for i in {1..5}; do
echo "$i"
done

Saída:

1
2
3
4
5

Exemplo 3: Loop for sobre arquivos em um diretório

Este exemplo percorre todos os arquivos .txt em um diretório e exibe o nome de cada arquivo.

#!/bin/bash
for arquivo in *.txt; do
echo "Encontrado arquivo: $arquivo"
done

O laço while em shell scripting

O laço while repete os comandos definidos em seu corpo enquanto uma condição testada for verdadeira. Ele é útil quando a quantidade de iterações não é definida e depende de uma condição.

Sintaxe básica do while

while [ condição ]; do
    Comandos a serem executados
done

Vejamos alguns exemplos do loop while em scripts do shell.

Exemplo 1: Loop while simples

Exibir no terminal a sequência de números de 1 a 5:

#!/bin/bash
contador=1
while [ $contador -le 5 ]; do
  echo "$contador"
  contador=$((contador + 1))
done

Saída:

1
2
3
4
5

Exemplo 2: Ler valores do terminal de forma sequencial.

O script a seguir solicita que o usuário digite um número no terminal. Ele repete a solicitação até que o usuário entre com o valor 0, momento em que o loop termina.

#!/bin/bash
# Inicializar com um valor diferente de 0 para entrar no loop
numero=-1
while [ $numero -ne 0 ]; do
  read -p "Digite um número (0 para sair): " numero
  echo "Você digitou: $numero"
done
echo "Fim do laço. Você digitou 0."

O laço until em shell scripting

O laço until é semelhante ao laço while, mas ele repete os comandos enquanto uma condição for falsa, e para a execução quando a condição se torna verdadeira.

Sintaxe básica do until

until [ condição ]; do
    Comandos a serem executados
done

Vejamos alguns exemplos.

Exemplo 1: Loop until simples

Este exemplo incrementa um contador até que ele atinja 5:

#!/bin/bash
contador=1
until [ $contador -gt 5 ]; do
  echo "$contador"
  contador=$((contador + 1))
done
echo "Sequência terminada."

Saída:

1
2
3
4
5
Sequência terminada.

Comandos de controle de loop

Existem comandos de controle que podem ser usados para manipular o comportamento de um loop:

• break: Sai do loop imediatamente.
• continue: Pula a iteração atual e vai para a próxima.

Vejamos como usá-los em scripts.

Exemplo: Uso de break

Este exemplo usa break para sair do loop se o contador atingir 3.

#!/bin/bash
for i in {1..5}; do
  if [ $i -eq 3 ]; then
    echo "Saindo do loop no número $i"
    break
  fi
  echo "Número: $i"
done

Saída:

Número: 1
Número: 2
Saindo do loop no número 3

Exemplo: Uso de continue

Este exemplo usa continue para pular a exibição do número 3.

#!/bin/bash
for i in {1..5}; do
  if [ $i -eq 3 ]; then
    continue
  fi
  echo "Número: $i"
done

Saída:

Número: 1
Número: 2
Número: 4
Número: 5

Excelente. Vamos propor agora alguns exercícios para você treinar o uso de laços de repetição em Shell Scripting. Resoluções sugeridas se encontram logo após a lista de exercícios.

Exercícios práticos com laços de repetição

1. Crie um script que exiba uma contagem regressiva de 10 a 1 usando um loop for.
2. Use um loop while para somar os números de 1 a 100 e exibir o resultado total.
3. Escreva um script que use o loop for para percorrer arquivos .txt em um diretório e exiba o nome de cada arquivo encontrado.
4. Use um loop until para solicitar uma senha até que o usuário digite a senha correta (“1234”).
5. Crie um loop for que percorra os números de 1 a 10, pulando o número 5 e saindo do loop quando chegar ao número 8.

Resolução dos exercícios

Exercício 1

#!/bin/bash
for i in {10..1}; do
  echo "Contagem regressiva: $i"
done

Exercício 2

#!/bin/bash
soma=0
contador=1
while [ $contador -le 100 ]; do
  soma=$((soma + contador))
  contador=$((contador + 1))
done
echo "A soma de 1 a 100 é: $soma"

Exercício 3

#!/bin/bash
for arquivo in *.txt; do
  echo "Arquivo encontrado: $arquivo"
done

Exercício 4

#!/bin/bash
senha=""
until [ "$senha" == "1234" ]; do
  read -sp "Digite a senha: " senha
  echo
done
echo "Senha correta!"

#Exercício 5: Usar break e continue em um loop

#!/bin/bash
for i in {1..10}; do
  if [ $i -eq 5 ]; then
    continue
  fi
  if [ $i -eq 8 ]; then
    break
  fi
  echo "Número: $i"
done

Conclusão

Os laços de repetição em Shell Scripting permitem criar fluxos de trabalho eficientes para manipular dados, arquivos e outros elementos de forma automatizada.

Aprender a usar for, while e until com comandos de controle como break e continue aumenta a flexibilidade e o controle que temos sobre o código, permitindo resolver problemas de forma mais simples e eficiente.

O post Como usar laços de repetição em Shell Scripting apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial mostro como podemos usar o comando SELECT no Linux para criar menus interativos em Shell Script para que o usuário possa ver e escolher uma opção específica em uma lista, que executará uma função programada qualquer.

Este comando se trata de uma construção de loop que exibe um menu numerado e aguarda a seleção do usuário para executar um código especificado.

Sintaxe

A sintaxe básica do comando SELECT é a seguinte:

select ITEM in [LISTA]
do
  [COMANDOS]
done

Onde LISTA pode ser uma sequência de strings separadas por espaços, a saída de um comando, um intervalo numérico, um array, etc.

Podemos criar um prompt personalizado para o menu select usando a variável de ambiente PS3.

Quando o bloco select é executado, cada item da lista é mostrado na tela, precedido por um número sequencial de identificação (“número do item”).

Quando o usuário digita um desses números (“escolhe um item”), esse valor é armazenado na variável REPLY, e o valor da variável ITEM recebe o item.

Um bloco de código pode ser associado a cada item que for escolhido, e será executado nesse momento. O select então realiza um loop e exibe novamente o menu, até que um comando break seja executado, encerrando o processo.

Exemplos

Vejamos um exemplo simples.

Exemplo 01

#!/bin/bash

PS3="Escolha um número: "

select autor in Asimov Clarke Herbert 'H. G. Wells' Tolkien Verne
do
  echo "Autor escolhido: $autor"
  echo "Número digitado: $REPLY"
done

Saída:

Este script irá exibir um menu que consiste nos nomes de autores com um número associado e o prompt definido na variável PS3. Quando o usuário digita um dos números, será impresso na tela o autor correspondente e seu número respectivo.

Note que o autor H. G. Wells foi colocado entre aspas, pois como o espaço é usado como separador de itens pelo select, seu nome (que contém espaços) seria interpretado de forma incorreta ao exibir o menu.

Para encerrar esse programa é necessário pressionar Ctrl+C, pois ainda não programamos uma rotina de saída com a instrução break, o que faremos no próximo exemplo.

Exemplo 02

No exemplo a seguir vamos criar um menu com opções de gerenciamento de pacotes que o usuário pode escolher, incluindo atualização das listas de repositórios, instalação de pacotes no sistema e manutenção do cache:

PS3="O que deseja fazer? "
select opcao in Atualizar Instalar 'Ver Cache' 'Limpar Cache' Sair
do
  case $opcao in
    Atualizar)
      sudo apt update
      ;;
    Instalar)
      read -p "Qual pacote deseja instalar? " pacote
      sudo apt install $pacote
    ;;
    'Ver Cache')
      ls /var/cache/apt/archives/
      ;;
    'Limpar Cache')
      sudo apt clean
      ;;
    Sair)
      break
      ;;
    *) 
      echo "A opção $REPLY é inválida"
    ;;
  esac
done

Neste exemplo usamos uma estrutura CASE para programar cada caso que o usuário pode vir a escolher, e incluímos uma opção para sair do menu e uma opção para tratar a escolha de um valor inválido, usando a variável de ambiente $REPLY.

Conclusão

Neste tutorial mostrei como usar, de forma simples, o comando “select” para criar menus interativos em Shell Script. Outras opções existem para esta tarefa, como as caixas de diálogo “dialog” e “whiptail“, e o emprego de bibliotecas externas como “ncurses”, “newt” e “zenity“, entre outras, que são abordadas em outros tutoriais aqui no site.

O post Como criar menus com o comando SELECT em Shell Script apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando printf  no Linux é uma ferramenta interna (built-in) do shell Bash e de outros como Ksh e Zsh que permite formatar e exibir uma saída de texto.

Este comando é útil para exibir informações em um formato específico no terminal, como por exemplo tabelas e relatórios.

Sintaxe

A sintaxe básica do comando “printf” é a seguinte:

$ printf FORMATO [ARGUMENTOS]

onde FORMATO é a string de formato que especifica como a saída será exibida, podendo conter caracteres normais a serem impressos na saída, caracteres de escape, flags e especificações de conversão, para descrição do formato da saída.

Os ARGUMENTOS (opcionais) são passados para os especificadores de formato e correspondem aos valores que serão exibidos de acordo com o formato especificado.

Exemplo:

$ printf "Dia da semana: %s\nHorário: %s\n" Sábado 11:00

Saída:

Dia da semana: Sábado
Horário: 11:00

Neste exemplo, o formato é a string Dia da semana: %s\nHorário: %s\n ao passo que “Sábado” e “11:00” são os argumentos. A string de formato possui caracteres de quebra de linha \n e dois especificadores de formato %s, que são substituídos pelos argumentos.

Caracteres de Escape

Os caracteres de escape mais comuns usados com printf são:

• \\ – Mostra um caractere de barra invertida
• \b – Backspace
• \n – Nova linha (quebra de linha)
• \r – Retorno de carro
• \t – Tabulação horizontal
• \v – Tabulação vertical

Especificações de formato

Uma especificação de formato tem a seguinte sintaxe:

%[flags][largura][.precisão]especificador

O especificador é um caractere que especifica como deve ser feita a interpretação do argumento correspondente. Este é um caractere obrigatório, sempre posicionado após os outros campos (diretivas, que são opcionais).

A seguir temos uma lista com alguns tipos de especificadores de conversão:

• %d – Imprime o argumento no formato de um inteiro decimal com sinal
• %i – Idem ao %d
• %u – Formato de um inteiro decimal sem sinal
• %o – Formato de um inteiro octal sem sinal
• %x – Formato de um inteiro hexadecimal sem sinal, com letras minúsculas
• %X – Idem %x, porém com letras maiúsculas
• %e – Formato de ponto flutuante em notação exponencial, com letras minúsculas
• %E – Idem %e, porém com letras maiúsculas
• %g, %G – Imprime o argumento com um número de ponto flutuante ou em notação exponencial, o que for mais adequado dependendo do valor e precisão fornecidos. $g imprime letras minúsculas e %G, maiúsculas.
• %c – Imprime o argumento com um caractere único
• %f – Formato de número de ponto flutuante.
• %s – Imprime o argumento como string
• %% – Imprime o símbolo literal %

Por exemplo, podemos imprimir um valor numérico em sistemas de numeração diferentes da seguinte forma:

$ printf "Decimal: %d\nHex: %x\nOctal: %o\n" 32 32 32

Saída:

Decimal: 32
Hex: 20
Octal: 40

No exemplo o número inteiro 32 é impresso nos sistemas decimal, hexadecimal e octal, respectivamente, pelo uso dos especificadores %d, %x e %o.

Diretiva de flags

A diretiva de flags (opcional) é empregada para realizar o ajuste de alinhamento, prefixos, preenchimento de zeros, etc.

Algumas das flags mais comuns incluem:

• – Alinha o texto impresso à esquerda dentro do campo – por padrão, o texto é alinhado à direita.
• + Precede os números exibidos com um sinal de + (números negativos são precedidos automaticamente por um sinal de -)
• 0 Preenche com zeros em vez de espaços em branco

Diretiva largura

A diretiva de largura é posicionada após qualquer caractere de flag, e especifica o número mínimo de caracteres que devem resultar na conversão.

Se a string de saída for menor que a largura especificada, será automaticamente preenchida com espaços em branco à esquerda. Vejamos um exemplo:

$ printf "%15s %d\n" Fábio 45

Saída:

            Fábio 45

Neste exemplo %15s significa que a largura deve ser de 15 caracteres. Como os valores “Fábio” e 305 possuem menos de 15 caracteres quando combinados, espaços à esquerda serão adicionados até completar essa largura ao exibir o resultado.

A saída é alinhada à direita por padrão; podemos alinhá-la á esquerda com o flag – (%-15s).

Diretiva de precisão

Esse modificador consiste em um ponto (.) seguido por um número inteiro positivo ou um asterisco, usados para ajustar a quantidade de caracteres numéricos, de string, ou a quantidade de casas decimais a serem mostradas.

A precisão funciona da seguinte forma:

• Se o tipo de conversão for um número inteiro, a precisão irá especificar a quantidade mínima de dígitos a serem impressos, acrescentando zeros à direita se necessário.
• Caso o tipo de conversão seja um número de ponto flutuante, a precisão irá especificar a quantidade de dígitos após o caractere de separação decimal (ou seja, as casas decimais). A precisão padrão é 6.
• E se o tipo da conversão for uma string, a precisão irá especificar o número máximo de caracteres a serem impressos. caso o número de caracteres no argumento seja maior que a precisão, a string será truncada (cortada).

Vejamos um exemplo:

$ printf "O valor de pi é %.4f \n" 3,14159265359

Saída:

O valor de pi é 3,1416

Note que o valor foi arredondado para 3,1416.

Se usarmos um asterisco, o valor da precisão será fornecido por um argumento de precisão que precede o argumento a ser formatado. Modificando o exemplo anterior teríamos:

$ printf "O valor de pi é %.*f" 4 3,14159265359

Saída:

O valor de pi é 3.1416

Exemplos de uso do comando printf em scripts

Vejamos agora exemplos de como usar o comando printf em scripts do shell Bash, para formatar a saída de dados exibida no terminal.

Exemplo 01

#!/bin/bash
printf "%s" "Qual seu nome completo?"
IFS= read -r nome_completo
printf "%s" "Qual sua idade?"
read idade
printf "Nome: %s\nIdade: %d\n" $nome_completo $idade

Neste exemplo, o comando “printf” é usado para formatar a saída do script com o nome e a idade fornecidos por uma pessoa. A string de formato especifica que o primeiro argumento deve ser exibido como uma string (“%s”) e o segundo como um número inteiro (“%d”).

No exemplo acima, o IFS= redefine a variável IFS para que nenhum caractere seja interpretado como separador de campo. Em seguida, o comando read é usado para ler a entrada do usuário e armazená-la na variável “nome_completo”.

Exemplo 02

Vejamos outro exemplo de uso do comando “printf”:

#!/bin/bash
printf "%-15s %5s\n" "Nome" "Idade"
printf "%-15s %5d\n" "João" 30
printf "%-15s %5d\n" "Maria" 25

Neste exemplo, o comando “printf” é usado para exibir uma tabela com o nome e a idade de duas pessoas. A string de formato especifica que o primeiro argumento deve ser exibido como uma string com largura de 15 caracteres e alinhado à esquerda (“%15s“) e o segundo como um número inteiro com largura de 5 caracteres e alinhado à direita (“%5d“).

Conclusão

O comando printf pode ser combinado com outras ferramentas do Bash Shell (e outros shells) para criar scripts mais avançados, como loops e condicionais. O importante é entender como o comando funciona e como ele pode ser usado para formatar e exibir uma saída de texto.

Lista com todos os artigos da Bóson Treinamentos

O post Formatar e exibir texto com o comando printf no terminal e em scripts apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O comando read é uma ferramenta do Bash Shell Scripting que permite ao script ler uma entrada de dados do teclado digitada pelo usuário e armazená-la em uma variável para processamento.

Esse comando é útil para solicitar ao usuário informações que precisam ser fornecidas durante a execução de um script, como um nome de arquivo, senha ou número de identificação, entre outros.

Sintaxe

A sintaxe básica do comando read é a seguinte:

read [opções] nome_variavel

Onde “opções” são as opções do comando e “nome_variavel” é o nome da variável na qual o valor digitado pelo usuário será armazenado.

A seguir, são listadas algumas opções comuns do comando read:

• -p: permite especificar uma mensagem para ser exibida antes da entrada de dados (string de prompt).
• -n: permite limitar o número de caracteres que podem ser digitados, ou seja, define o número máximo de caracteres que o comando read lerá.
• -s: permite ocultar a entrada de dados, como ao digitar uma senha ou outras informações confidenciais.
• -r: Impede que o comando read interprete caracteres de escape (como ”, ‘\n’ e ‘\t’) como comandos especiais. Útil quando você deseja ler arquivos de texto brutos.
• -a: Lê a entrada do usuário em um array.

Exemplos de uso do comando read

Vejamos alguns exemplos de uso do comando read em scripts simples do shell.

Exemplo 1. Vamos criar um arquivo de texto de nome “teste.sh” e digitar o código a seguir neste arquivo:

#!/bin/bash
echo "Qual é o seu nome?"
read nome
echo "Olá, $nome!"

Neste exemplo, o usuário é solicitado a digitar seu nome e a entrada é armazenada na variável “nome”. Em seguida, o script exibe uma mensagem de boas-vindas com o nome fornecido.

Para testar, salve e feche o arquivo, e dê permissão de execução ao arquivo no terminal:

$ chmod u+x teste.sh

E então rode o script:

$ ./teste.sh

Exemplo 2. Também é possível usar o comando read para solicitar várias informações de uma vez só, separando as variáveis com espaços ou vírgulas. Vamos alterar o script teste.sh para pedir o primeiro nome e a idade do usuário:

#!/bin/bash
read -p "Digite seu primeiro nome e idade: " nome idade
echo "Seu nome é $nome e você tem $idade anos."

Neste exemplo, o usuário é solicitado a digitar seu nome e sua idade, em sequência (pressionando enter somente no final) que são armazenados nas variáveis correspondentes.
Em seguida, o script exibe uma mensagem com as informações fornecidas pelo usuário.

Exemplo 3. Podemos ler dados sensíveis no terminal, como senhas, sem que sejam exibidas durante a digitação. Para isso usamos a opção -s do comando read, como mostra o exemplo a seguir:

#!/bin/bash
read -p "Digite seu nome de usuário: " nome
read -s -p "Entre com sua senha: " senha
echo -e "\nBem-vindo ao sistema, $nome!."
echo -e "\nA senha escolhida foi $senha."

Exemplo 4. Por padrão, o comando read em shell scripting interpreta um espaço como um separador de campo e, portanto, interrompe a leitura da string assim que encontrar um espaço.

Para ler uma string que contém espaços, é necessário ajustar o separador de campo para que o comando read reconheça a entrada do usuário como uma única string. Podemos fazer isso usando a variável de ambiente IFS (Internal Field Separator) do shell:

echo "Digite seu nome completo:"
IFS= read -r nome_completo
echo "Seu nome completo é $nome_completo"

No exemplo acima, o IFS= redefine a variável IFS para que nenhum caractere seja interpretado como separador de campo. Em seguida, o comando read é usado para ler a entrada do usuário e armazená-la na variável “nome_completo”.

Finalmente, a string digitada pelo usuário é exibida na tela usando o comando echo.

Com isso, o comando read irá ler a entrada do usuário até que a tecla “Enter” seja pressionada, permitindo que o usuário digite seu nome completo, mesmo com espaços em branco.

Conclusão

O comando read pode ser combinado com outras ferramentas do shell Bash para criar scripts mais avançados, como loops e condicionais. O importante é entender como o comando funciona e como ele pode ser usado para interagir com o usuário.

Para saber mais sobre o comando read e conhecer todas as suas opções, consulte as páginas de manual do comando com man read.

O post Ler entrada de dados com comando read em Shell Scripting apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Em muitos de nossos scripts temos utilizado a sequência de caracteres 3>&1 1>&2 2>&3. Mas o que significam esses caracteres exatamente, e quando devemos empregá-los?

Bem, os números representam os descritores de arquivos (file descriptors), dos quais existem três padronizados no Linux:

• 0 – STDIN (a entrada padrão)
• 1 – STDOUT (a saída padrão)
• 2 – STDERR (o erro padrão)

Os descritores de arquivos podem ser redirecionados para um arquivo, com o uso do símbolo >, ou ainda para outro descritor de arquivo, com o uso de >&.

Desta forma, temos três redirecionamentos ocorrendo no exemplo:

3>&1 – Cria um novo descritor de arquivos e o redireciona para a saída padrão (1)

1>&2 – Redireciona a saída padrão para o erro padrão (2)

2>&3 – Redireciona o erro padrão para o descritor criado, que agora irá redirecionar para a saída padrão.

Portanto, se nosso script escrever algo no descritor 2, os dados serão redirecionados para o descritor 1, e vice-versa. Alguns comandos escrevem informações no descritor STDERR, e com o uso desses redirecionamentos podemos encaminhar os dados para a saída padrão, de modo que o usuário possa visualizá-los.

Aqui temos um exemplo de uso em um script do shell: comando whiptail (veja o exemplo de número 6).

Você pode aprender mais sobre os redirecionamentos e os descritores de arquivos assistindo ao vídeo da Bóson Treinamentos a seguir:

O post O que significa 3>&1 1>&2 2>&3 em um script do Shell no Linux? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O Zenity é um software que permite criar diversos tipos de caixas de diálogo simples para interação com os usuários em um ambiente Linux, que podem ser utilizadas em scripts do shell.

Por exemplo, podemos criar um diálogo para obter informações do usuário, como uma data em um calendário ou um valor numérico em uma caixa de texto, ou ainda criar diálogos para exibir informações, como uma barra de progresso para mostrar o status de uma operação, ou caixas de aviso e de erro.

O Zenity utiliza o GTK, conjunto de bibliotecas utilizado para a construção de interfaces gráficas.

Por padrão, ele vem instalado na grande maioria das distribuições Linux, de modo que seja provável que o programa já esteja presente em sua distro. Verifique a presença do programa emitindo o comando  seguir no terminal:

zenity --version

Se o programa estiver instalado, será exibida a versão do programa. A versão mais recente é a 3.22.0 (na data de elaboração deste tutorial).

Caso contrário, instale-o usando os seguintes comandos:

Sistemas Debian / Ubuntu:

sudo apt-get install zenity

Sistemas Red Hat / CentOS:

yum install zenity

Sintaxe

A sintaxe básica para uso do programa é a seguinte:

zenity [opções-comuns] [tipo-de-diálogo] [opções-específicas-do-diálogo]

Tipos de Caixas de Diálogo

O Zenity permite criar os seguintes tipos de caixas de diálogo:

• Calendar
• File selection
• Forms
• List
• Notification icon
• Message
  • Error
  • Information
  • Question
  • Warning
• Password entry
• Progress
• Text entry
• Text information
• Scale
• Color selection

Códigos de saída

Os seguintes códigos de saída são retornados ao executar o programa:

Opções Comuns

No Zenity, todas as caixas de diálogo suportam as seguintes opções gerais:

–title=title
Especifica o título da caixa de diálogo.
–window-icon=icon_path
Especifica o ícone que é exibido na janela da caixa de diálogo. Existem 4 tipos de ícones disponíveis      que podem ser selecionados usando-se as seguintes palavras-chave: “info”, “warning”, “question” e “error”.
–width=width
Especifica a largura caixa de diálogo.
–height=height
Especifica a altura caixa de diálogo.
–timeout=timeout
Especifica o timeout em segundos após o qual a caixa de diálogo é fechada.

Outras opções

–about
Mostra o diálogo Sobre o Zenity, o qual contém informações sobre a versão do Zenity, copyright e informações sobre os desenvolvedores do software.
–version
Mostra o número de versão do programa.

Caixa de Diálogo File Selection (Seleção de Arquivos)

Com esta caixa o usuário pode selecionar um arquivo a partir de um diretório, e o arquivo é retornado na saída padrão.
O modo padrão de operação do diálogo de seleção de arquivos é o modo open (abrir).

Opções principais:

–filename=NOME_ARQUIVO
Especifica o arquivo ou diretório a ser selecionado na caixa de seleção quando a caixa é exibida pela primeira vez

–multiple
Permite a seleção de múltiplos nomes de arquivo na caixa de diálogo de seleção

–directory
Permite apenas a seleção de diretórios na caixa de seleçãoo

–save
Permite configurar o diálogo de seleção de arquivos no modo Save (salvar)

–separator=SEPARADOR
Especificar a string que será utilizada para dividir a lista de nomes de arquivos retornada.

–file-filter=FILTRO
Permite usar um filtro para especificar o tipo de arquivos que deverá se exibido no diálogo

Exemplos

Vejamos alguns exemplos de uso do utilitário em scripts do shell:

Exemplo 01 – Caixa de diálogo de erro, contendo um botão OK (digitar o comando diretamente no terminal):

zenity --title "Problema detectado"  --error --text="Arquivo requisitado inválido."

Exemplo 02 – Caixa de diálogo de texto. Crie um arquivo de texto e entre com os comandos a seguir. Logo após, salve o arquivo com o nome de teste-zenity.sh e dê permissão de execução ao script com o comando chmod 755 teste-zenity.sh:

#!/bin/bash
nome=$(zenity --title="Nome?" --text "Qual é o seu nome?" --entry)
zenity --info --title="Boas-vindas" --text=" $nome" --width="100" height="50"
sobrenome=$(zenity --title="Sobrenome" --text "$primeiro Qual é o seu sobrenome?" --entry)
zenity --info --title="Bóson Treinamentos" --text="Bons estudos, $nome $sobrenome"

Para rodar o script, execute o comando a seguir:

./teste-zenity.sh

Veja duas telas deste script em execução:

Exemplo 03: Exibindo um diálogo de calendário, capturando a data escolhida pelo usuário em uma variável, e exibindo a data no terminal:

#!/bin/bash
# Capturando a data escolhida pelo usuário a partir de um calendário
data=$(zenity --title="Escolha a data" --calendar)
if (( data ))
then
  echo "A data escolhida foi o dia $data"
else
  echo "Usuário não escolheu nenhuma data"
fi

Exemplo 04: Usando uma caixa de diálogo de seleção de arquivos para selecionar um arquivo de texto:

#!/bin/bash
# Selecionando um arquivo de texto a partir de uma caixa de diálogo

ARQUIVO=$(zenity --file-selection --title="Selecione um arquivo")

case $? in
    0)
        echo "$ARQUIVO selecionado.";;
    1)
        echo "Nenhum arquivo selecionado.";;
    -1)
        echo "Ocorreu um erro desconhecido.";;
esac

Exemplo 05: Abrindo um arquivo de texto com extensão .sh e exibindo seu conteúdo em uma caixa de diálogo:

#!/bin/bash
# Selecionando um arquivo de texto a partir de uma caixa de diálogo
ARQUIVO=$(zenity --file-selection --title="Selecione um arquivo" --file-filter="*.sh")
# Usando o diálogo Text Information para exibir o conteúdo do arquivo selecionado:
if [ $ARQUIVO ]
then
    zenity --text-info --title="Arquivo" --filename=$ARQUIVO --width=450 --height=500
fi

Exemplo 06: Criando um formulário para captura de dados para um cadastro de usuário:

#/bin/bash
# Criando um formulário com o Zenity
DADOS=$(zenity     --forms --title="Cadastro" --text="Preencha o formulário a seguir com seus dados:" \
    --separator="," \
    --add-entry="Nome" \
    --add-entry="Sobrenome" \
    --add-calendar="Data de Nascimento" \
    --add-entry="E-mail")
echo $DADOS | cut -d, -f1
echo $DADOS | cut -d, -f2
echo $DADOS | cut -d, -f3
echo $DADOS | cut -d, -f4

Exemplo 07: Selecionando itens em uma lista de itens:

#/bin/bash
# Usando uma lista com botões de rádio com o Zenity
ITEM_SELECIONADO=$(zenity  --list  --text "Selecione seu sistema favorito" \
    --radiolist \
    --column "Marcar" \
    --column "Sistemas" \
    FALSE BSD TRUE Linux FALSE "OS X" FALSE Windows);
echo "Seu sistema operacional favorito é o $ITEM_SELECIONADO";

É isso aí! Vimos alguns exemplos do uso do Zenity para criar caixas de diálogo no Linux. Se você quiser se aprofundar no assunto, recomendo uma consulta à página oficial do manual do Zenity: https://help.gnome.org/users/zenity/3.22/

O post Zenity – Exibindo caixas de diálogo com scripts do Shell no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Na lição passada vimos o funcionamento e aplicação da declaração break em scripts do shell. Neste tutorial vamos trabalhar com a declaração break em loops aninhados, mostrando como utilizá-la para escolher qual loop interromper.

Às vezes, em um algoritmo que possui loops aninhados,  precisamos interromper a execução do loop mais externo de acordo com uma condição que ocorre no loop interno (aninhado). Para isso, podemos usar o comando break de acordo com a seguinte sintaxe:

break n

onde o valor n indica o nível do loop que será interrompido. Por padrão, esse valor é 1, o que significa que o loop interrompido é o loop onde a instrução break se encontra. Se ajustarmos o valor de n para, por exemplo, 2, o comando break irá interromper a execução do próximo nível, que corresponde ao loop externo em relação ao atual, e assim sucessivamente para estruturas de repetição aninhadas mais complexas.

Vejamos dois exemplos.

Exemplo 01: Encerrando o loop interno (usando laços for).

Neste exemplo o comando break termina o loop interno quando o valor da variável y é igual a 12, mas o loop externo continua a ser executado (5 vezes):

#!/bin/bash
# Saindo de um loop interno

for (( x = 1; x <= 5; x++ ))
do
   echo "Valor do loop externo: $x"
   for (( y = 1; y < 20; y++ ))
   do
      if [ $y -eq 12 ]
      then
         break
      fi
      echo "Valor no loop interno: $y"
   done
done

Exemplo 02: Encerrando o loop externo. 

Neste exemplo, o loop mais externo (nível 2) é interrompido quando, no loop mais interno (nível 1) o valor da variável y se torna maior do que 9:

#!/bin/bash
# Saindo de um loop externo

for (( x = 1; x < 5; x++ ))
do
   echo "Valor do loop externo: $x"
   for (( y = 1; y < 20; y++ ))
   do
      if [ $y -gt 9 ]
      then
         break 2
      fi
      echo "Valor no loop interno: $y"
   done
done

É isso aí! Na próxima lição vamos tratar do comando continue, que permite interromper a execução de comandos dentro de um loop prematuramente sem no entanto finalizar o loop em si completamente,

O post Shell Scripting – Declaração break em loops aninhados apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Comando break

O comando ou declaração break é uma forma simples de sair de um loop em execução, interrompendo-a em um momento definido.
Pode ser utilizado em laços for, while e do while.

Exemplos:

1. Saindo de um laço simples. Neste caso, pedimos para que sejam mostrados no terminal os número de 1 até 10, por meio de um laço for, mas usamos o comando break para interromper a execução desse loop quando o número a ser exibido tem o valor 6:

#!/bin/bash
for num in 1 2 3 4 5 6 7 8 9 10
do
  if [ $num -eq 6]
  then
    break
  fi
  echo "Número: $num"
done
echo "Laço for finalizado"

2. Usando laço while. Neste segundo exemplo, pedimos para o usuário entrar com um número entre 1 e 10 no terminal, e o exibimos logo na sequência.

O loop continuará a ser executado enquanto o usuário digitar um número diferente de zero, e será encerrado caso o número 0 seja digitado.

Porém, se o usuário entrar com um número maior do que dez, o comando break será utilizado para encerrar o loop prematuramente e, então, uma mensagem será exibida após o encerramento do laço de acordo com o valor que o usuário digitou:

#!/bin/bash
# Testando comando break em um laço while
read -p "Digite um número entre 1 e 10 " num
while [ $num -ne 0 ]
do
  if [ $num -gt 10 ]
  then
    break
  fi
  echo "Número digitado: $num"
  read -p "Digite um número entre 1 e 10: " num
done
if [ $num -eq 0 ]
then
  echo "Você encerrou o programa digitando zero"
else
  echo "Você digitou um valor maior do que 10. Programa finalizado"
fi

No próximo tutorial vamos utilizar o comando break em laços aninhados, de modo a escolhermos qual laço será finalizado.

O post Shell Scripting – Declaração break – Saindo de loops apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O Shell Bash trata as funções como se fossem mini-scripts, completas com um status de saída próprio. É possível gerar u status de saída para a funções de três maneiras diferentes:

1. Status de Saída Padrão

Por padrão, o status de saída de uma função é o status de saída retornado pelo último comando executado na função.

Após a execução da função, usamos a variável padrão $? para determinar o status de saída da função.

Exemplo:

#!/bin/bash
# Status de saída padrão da função
testaarquivo() {
  echo "Verificando arquivo"
  ls -l xyz.abc
}
testaarquivo
echo "O status de saída é $?"

Veja a saída gerada ao executarmos esse script:

O status de saída foi 2, porque o último comando na função falhou (não há o arquivo xyz.abc; se ele existisse, o status seria 0). Porém, não é possível saber se outros comandos – caso existissem – anteriores a esse, foram executados com sucesso ou não, baseando-se no status de saída da função. Desta forma, confira no status de saída padrão de uma função não é recomendável para monitorar o que ocorre com as funções dentro de um script.

2 – Usando o comando return

O shell bash usa o comando return para sair de uma função com um status de saída específico. Com esse comando podemos especificar um valor inteiro para definir o status de saída da função, de forma programável.

O valor de retorno deve ser obtido com a variável $? assim que a função termina sua execução, e um status e saída só pode ser um valor inteiro no intervalo entre 0 e 255.

Não é possível usar essa técnica se for necessário retornar um valor inteiro muito grande (fora da faixa) ou ainda um valor que seja uma string.

Exemplo:

#!/bin/bash
# Usando o comando return na função
function valor {
 read -p "Digite um número entre 0 e 255: " num
 return $[ $num ]
}

valor
echo "O valor do status retornado é $?"

Veja o resultado obtido após executar o script acima, fornecendo o valor 45 quando solicitado:

O status de saída é exatamente o número que fornecemos, ou seja, o valor que nós determinamos para a função. Porém, se fornecermos um valor fora da faixa entre 0 e 255 teremos um status de saída com valor diferente do esperado – e errado.

3 – Usando a saída da função

Sabemos que é possível capturar a saída de um comando em uma variável do shell usando os caracteres backtick (` `); também é possível capturar a saída de uma função em uma variável do shell com essa técnica. Assim podemos obter qualquer tipo de saída de uma função e atribui-la a uma variável.

Usamos para isso a seguinte sintaxe:

saida=`função`

A saída da função será atribuída à variável do shell criada (no caso, à variável de nome $saida).

Exemplo:

#!/bin/bash
function valor {
  read -p "Digite um número qualquer: " num
  echo $[num]
}
saida=`valor`
echo "O valor do status retornado é $saida"

Veja o resultado obtido com a execução desse script. Vamos fornecer o valor 1024 quando solicitado pela função:

Com essa técnica, podemos capturar valores inteiros, de ponto flutuante e até mesmo valores de strings como status de saída de funções.

É isso aí! Na próxima lição, vamos estudar o uso de variáveis em funções em Shell Scripting no Linux.

O post Curso de Shell Scripting – Retornando valores em funções e status de saída apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O pacote dialog é uma ferramenta criada originalmente por Savio Lam. Este pacote permite criar caixas de diálogo padrão em janelas em um ambiente de texto, usando códigos de controle de escape ANSI.

Podemos incorporar estas caixas de diálogo em nossos script do shell para que haja interação com os usuários.

O pacote dialog não é instalado por padrão em muitas distribuições Linux. Se ele não estiver presente em seu sistema, instale-o com os comandos a seguir:

Em sistemas Debian / Ubuntu:

# apt-get install dialog

Em sistemas Red Hat / Fedora / CentOS:

# yum install dialog

O comando dialog utiliza parâmetros de linha de comando para determinar que tipo de widget de janela deve ser criada. Um widget é um tipo de elemento de janela. Podemos ver na tabela a seguir alguns dos tipos de widgets suportados pelo pacote dialog:

Para especificarmos um widget na linha de comandos, usamos a seguinte sintaxe:

dialog --widget parâmetros

Cada widget fornece saída em duas formas:

• usando o erro padrão STDERR
• usando o código de status de saída

O código de status do comando dialog determina o botão selecionado pelo usuário. Caso o botão selecionado seja Yes ou OK, o status de saída retornado será 0; se um botão Cancel ou No for selecionado, o comando dialog retornará um status de saída igual a 1. E caso o usuário pressione a tecla ESC, o status de saída será igual a 255. Desta forma, podemos usar a variável padrão $? para determinar qual ação foi selecionada na caixa de diálogo.

Agora, caso o widget retorne dados, como uma palavra ou a seleção de um menu, o comando dialog enviará esses dados para STDERR. Assim podemos usar as técnicas de redirecionamento de saída para redirecionar os dados para STDOUT ou qualquer outro arquivo, como no exemplo abaixo:

$ dialog --inputbox “Digite seu nome:” 10 20 2>nome.txt

Este comando redireciona o texto digitado na caixa de texto para o arquivo nome.txt. Os números 10 20 indicam o tamanho da janela, sendo no caso 10 linhas por 20 colunas.

Vamos estudar agora exemplos de uso dos diversos widgets:

1. Caixa de mensagens – msgbox

Mostra uma mensagem simples em uma janela e espera o usuário pressiona um botão OK para desaparecer.

Sintaxe:

dialog --title título_caixa --msgbox texto_a_mostrar altura largura

Exemplo:

$ dialog --title “Caixa de Exemplo” --msgbox “Testando uma msgbox” 10 35

2. Widget yesno

O widget yesno permite que o usuário esponda a uma questão do tipo Sim / Não mostrada na tela. O status de saída do comando dialog depende de qual botão é escolhido. Se for o botão No, o status de saída será 1; se for o botão Yes, o status de saída será 0.

Exemplo:

$ dialog --title “Caixa yesno” --yesno “Escolha Sim ou Não” 10 25

3. A caixa inputbox

A caixa inputbox fornece uma caixa de texto simples para que o usuário entre com uma string qualquer. O comando dialog envia o valor do texto digitado para o STDERR. Podemos então redirecionar esse valor para obtermos a informação digitada, o que faremos com o parâmetro –stdout.

Exemplo:

$ nome=$(dialog --inputbox “Digite seu nome” 10 25 --stdout)
$ echo $?
$ echo $nome

4. O widget textbox

Com o widget textbox podemos mostrar uma grande quantidade de informações em uma janela. Ele produz uma janela com rolagem que contém o texto proveniente de um arquivo especificado.

Exemplo:

$ dialog --textbox /etc/group 20 20

5. O widget menu

O widget menu permite criar um menu de itens selecionáveis a partir de uma tag de seleção e um texto descritivo de cada item

Exemplo:

$ sistema=$(dialog --menu “Escolha o sistema” 20 35 15 \
1 “Linux” \
2 “BSD” \
3 “Solaris” \
4 “ Android” --stdout)
$ echo $sistema

No exemplo o caractere \ é utilizado para que possamos continuar a digitação do comando na linha abaixo. Capturamos o valor escolhido na variável sistema, e em seguida exibimos seu valor no console com o comando echo.

6. Widget calendar

Usamos o widget calendar para que o usuário possa selecionar uma data em uma janela gráfica.

Exemplo:

$ data=$(dialog --calendar “Escolha a data” 0 0 --stdout)
$ echo $data

Usamos a opção –stdout para redirecionar a informação selecionada para a saída padrão, onde será atribuída à variável data.

7. Trabalhando com caixa de informações – infobox:

O infobox é um widget bem simples, que vostra uma mensagem sem esperar por uma resposta do usuário.

Exemplo:

$ dialog --title “Sucesso” --infobox “Operação Concluída” 5 35; sleep 4; clear

Usamos o comando sleep 4 para que a janela permaneça por 4 segundos antes de encerrar o widget.

8. Usando um checklist

Um checklist permite apresentar um conjunto de itens dos quais o usuário pode selecionar quantos desejar usando a barra de espaços do teclado.

Exemplo:

$ itens=$(dialog --checklist “Escolha a cor:” 15 30 4 \
“Verde” “” OFF \
“Azul” “” OFF \
“Amarelo” “” ON \
“Preto” “” OFF --stdout)
$ echo $itens

Os itens pré-selecionados devem usar a palavra ON, e os não selecionados automaticamente usam a palavra OFF. Também devemos indicar o número de itens logo após as dimensões da janela (em nosso caso, 4 itens).

9. Usando um radiolist

O radiolist é similar ao checklist, com a diferença de que só é possível escolher um dos itens apresentados.

Exemplo:

$ itens=$(dialog --radiolist “Escolha a cor:” 15 30 4 \
“Verde” “” OFF \
“Azul” “” OFF \
“Amarelo” “” ON \
“Preto” “” OFF --stdout)
$ echo $itens

10. Usando um timebox

Vamos ver agora o uso básico de um widget timebox

Exemplo

$ hora=$(dialog --stdout --title “Relógio” --timebox “Escolha o horário:” 0 0)
$ echo “ A hora escolhida foi $hora”

É isso aí pessoal! Agora é só caprichar em seus scripts usando essa ferramenta excelente. E não deixem de conferir nosso artigo Criando caixas de diálogo via Shell Scripting usando a ferramenta whiptail, além de assistir ao nosso vídeo sobre a ferramenta dialog em Shell Scripting:

O post Shell Scripting – Criando caixas de diálogo TUI com dialog apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.