O comando sleep, no Linux, é empregado para pausar um processo por um período de tempo especificado na forma de um ou mais argumentos passados a ele. Esse tempo pode ser especificado em segundos (padrão), minutos, horas ou dias.

Sintaxe

$ sleep numero [opções|unidades]...

Onde numero é um valor inteiro positivo, seguido por uma unidade de tempo opcional. Se a unidade de tempo não for especificada, será assumida como sendo tempo em segundos, por padrão.

As unidades aceitas pelo sleep são as seguintes:

• s: segundos
• m: minutos
• h: horas
• d: dias

É possível passar mais de um valor de tempo ao comando, e nesse caso os valores são somados automaticamente para resultar no valor da temporização final.

No lugar de numero também é possível usar a palavra inf, que significa pausa infinita.

As únicas opções disponíveis para o sleep são –help (para ajuda do comando) e –version (consultar versão).

Para que usamos exatamente o comando sleep?

O comando sleep pode ser usado em diversas tarefas em um sistema Linux, tais como:

• Sincronização de processos, permitindo inserir atrasos entre comandos ou processos, garantindo a execução sequencial correta.
• Economia de recursos ao usar scripts ou loops, sendo possível reduzir o uso de CPU ao aguardar antes de novas tentativas ou verificações.
• Automação de tarefas repetitivas em intervalos de tempo em scripts.

Entre outras.

Exemplos do comando sleep

Pausar por 10 segundos:

$ sleep 10

Pausar por 5 minutos:

$ sleep 5m

Pausar por 1 minuto e 30 segundos:

$ sleep 1m 30s

Pausar infinitamente:

$ sleep inf

Pausar por 300 milissegundos:

$ sleep 300e-3

Neste exemplo, 300e-3 significa 300 x 10-3, ou seja, 300/1000 = 300ms

Gerenciamento de tarefas em sequência

Podemos criar um script que execute tarefas em sequência, mas com intervalos temporais definidos:

#!/bin/bash
./processo1.sh
sleep 30 # Aguarda 30 segundos antes de iniciar o próximo processo.
./processo2.sh

Repetição com intervalo de tempo em loops

Também podemos usar o sleep para inserir pausas em scripts que realizem repetição de tarefas:

while true; do
  echo "Verificando servidor..."
  sleep 10 # Aguarda 10 segundos antes de repetir.
done

Conclusão

O comando sleep, como visto, é uma ferramenta simples, porém bastante útil no Linux, especialmente quando usado em scripts e para automação de processos.

Com ele podemos temporizar execuções, economizar recursos e sincronizar processos em sistemas e aplicações.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Pausar processos com temporização com o comando sleep no Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

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.

O comando echo no Linux é uma ferramenta utilizada para exibir mensagens, variáveis e resultados do processamento de scripts diretamente no terminal. Ele é muito empregado em scripts, mas também pode ser usado interativamente para imprimir texto e informações no console.

Neste tutorial, vamos explorar o comando echo e seus principais usos com vários exemplos, incluindo algumas de suas opções mais úteis.

Sintaxe básica do comando echo

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

echo [opções] [texto]

O comando echo exibe o texto ou o valor das variáveis passadas como argumento diretamente no terminal. Vejamos alguns exemplos agora.

Exemplos básicos de uso do echo

1. Exibir uma mensagem simples

echo "Bóson Treinamentos!"

Esse comando exibe a mensagem “Bóson Treinamentos!” no terminal.

2. Exibir texto com variáveis

O echo pode exibir valores armazenados em variáveis. Para isso, basta utilizar o caractere $ antes do nome da variável, como no exemplo a seguir:

nome="Isaac Newton"
echo "Bem-vindo, $nome!"

Saída:

Bem-vindo, Isaac Newton!

Principais opções do comando echo

O echo oferece algumas opções bastante úteis que permitem personalizar a saída:

• -n: Evita a quebra de linha no final da saída.
• -e: Permite o uso de caracteres de escape (como \n para nova linha, \t para tabulação).
• -E: Desativa o uso de caracteres de escape (geralmente já é o comportamento padrão).
• –version: Mostra informações sobre a versão do comando e sai

Vejamos alguns exemplos de uso do comando echo com essas opções.

Exemplos com as opções do echo

Exemplo 1: Usar -n para evitar a quebra de linha

Por padrão, echo adiciona uma nova linha ao final da saída. Com -n, essa quebra de linha é removida.

echo -n "Esta linha não termina com uma quebra de linha."
echo " Próxima linha será exibida na mesma linha."

Saída:

Esta linha não termina com uma quebra de linha. Próxima linha será exibida na mesma linha.

Ou ainda:

echo -n "Esta linha não termina com uma quebra de linha" && echo "Próxima linha será exibida na mesma linha"

Exemplo 2: Usar a opção -e para caracteres de escape

A opção -e permite adicionar caracteres especiais na saída. Alguns dos mais comuns são:

• \n: Nova linha
• \t: Tabulação
• \\: Barra invertida literal

Por exemplo:

echo -e "Linha 1\nLinha 2"

Saída:

Linha 1
Linha 2

Outro exemplo:

echo -e "Coluna 1\tColuna 2"

Saída:

Coluna 1    Coluna 2

Exemplo 3: Exibir aspas e caracteres especiais

Para exibir aspas duplas ou outros caracteres especiais, podemos usar a barra invertida \ para escape:

echo "\"Esse é um texto entre aspas\""

Saída:

"Esse é um texto entre aspas"

Usos comuns do echo

1. Exibir o conteúdo de variáveis de ambiente

Variáveis de ambiente, como $HOME, $USER e $PATH, contêm informações importantes sobre o sistema e o usuário atual. O echo é útil para acessar e mostrar esses valores rapidamente.

echo "Usuário atual: $USER"
echo "Diretório pessoal: $HOME"
echo "Caminho de busca: $PATH"

Saída:

Usuário atual: nome_do_usuário
Diretório pessoal: /home/nome_do_usuário
Caminho de busca: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

2. Exibir o resultado de comandos embutidos

O echo pode ser usado para exibir o resultado de outros comandos usando a sintaxe de substituição $(COMANDO):

echo "Data atual: $(date)"
echo "Diretório atual: $(pwd)"

Saída:

Data atual: Mon Oct 25 10:30:00 UTC 2024
Diretório atual: /home/nome_do_usuário

3. Escrever em um arquivo com echo

O echo também pode ser usado para escrever conteúdo em arquivos. Para isso, simplesmente usamos o operador de redirecionamento >:

echo "Texto de exemplo" > exemplo.txt

Esse comando cria o arquivo exemplo.txt (ou o sobrescreve se ele já existir) e insere “Texto de exemplo” nele.

Para adicionar ao final do arquivo sem sobrescrevê-lo, usamos >>:

echo "Outra linha" >> exemplo.txt

4. Usar o echo para criar quebras de linha e tabulações

Quando queremos formatar a saída do terminal com espaços e quebras de linha, o echo com com a opção -e facilita essa tarefa. Podemos criar mensagens organizadas, como em tabelas simples:

echo -e "Produto\tQuantidade\tPreço"
echo -e "Caneta\t10\t\t1.50"
echo -e "Caderno\t5\t\t4.00"

Saída:

Produto Quantidade Preço
Caneta  10         $1.50
Caderno 5          $4.00

Conclusão

O comando echo é uma ferramenta bastante usada para exibir informações no terminal e manipular texto. Com suas opções, ele permite criar saídas formatadas, armazenar dados em arquivos e acessar variáveis do sistema.

Esses recursos são úteis tanto no uso interativo quanto em scripts, permitindo uma comunicação clara e personalizada no terminal.

O post Como exibir mensagens com o comando echo no terminal do Linux 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.

Por Fábio dos Reis

O shell Bash é, sem dúvidas, o mais comum e utilizado em ambientes Linux e Unix. Por conta disso, o domínio de sua utilização é muito importante para que o administrador do sistema, ou mesmo usuário comum, possa trabalhar com eficiência e alta performance.

Neste artigo trazemos uma série de atalhos de teclado do bash, que permitem ao usuário operar com muito mais facilidade e agilidade em uma série de tarefas triviais e também complexas.

Vamos aos atalhos, separados por categorias de aplicação dos comandos:

Edição na linha de comandos:

Ctrl + a
Voltar para o início da linha de comandos

Ctrl + e
Ir para o final da linha de comandos

Ctrl + k
Apagar caracteres a partir da posição do cursor até o final da linha de comandos

Ctrl + u
Apagar caracteres a partir da posição do cursor até o início da linha de comandos

Ctrl + w
Apagar caracteres a partir da posição do cursor até o início da palavra – apaga uma palavra

Ctrl + y
Cola uma palavra ou texto que foi recortada usando um atalho de exclusão após o cursor

Ctrl + xx
Mover o cursor entre o início da lnha de comandos e a posição atual dele, ida e volta.

Alt + b
Mover o cursor uma palavra para trás (direção do início da linha de comandos), ou ir para o início da palavra onde o cursor está posicionado atualmente.

Alt + f
Mover o cursor uma palavra para frente (direção do final da linha de comandos), ou ir para o final da palavra onde o cursor está posicionado atualmente.

Alt + d
Exclui os caracteres até o final da palavra, iniciando na posição atual do cursor, o que significa a palavra inteira se o cursor estiver no início da palavra

Alt + c
Capitalizar (tornar maiúscula) o caractere onde o cursor está posicionado, e mover o cursor para o final da palavra.

Alt + u
Colocar os caracteres em caixa alta (maiúsculas) a partir da posição do cursor até o final da palavra

Alt + l
Colocar os caracteres em caixa baixa (minúsculas) a partir da posição do cursor até o final da palavra

Alt + t
Trocar a palavra atual com a anterior

Ctrl + f
Mover o cursor um caractere adiante

Ctrl + b
Mover o cursor um caractere para trás

Ctrl + d
Apaga o caractere sob o cursor

Ctrl + h
Apaga o caractere anterior á posição do cursor

Ctrl + t
Troca o caractere sob o cursor com o caractere anterior a ele

Trabalhando com o histórico:

Ctrl + r
Procurar os comandos anteriores do histórico (busca reversa)

Ctrl + g
Sair do modo de busca do histórico

Ctrl + p
Mostra o comando anterior no histórico (volta no histórico) -> similar à seta para cima

Ctrl + n
Mostra o comando posterior no histórico (avança no histórico) -> similar à seta para baixo

Alt + .
Usar a última palavra do comando anterior

Controle de comandos:

Ctrl + l
Limpa a tela

Ctrl + s
Interrompe a saída na tela, para comandos que exibem saída verbosa muito longa.

Ctrl + q
Permite a saída na tela, caso tenha sido interrompida com Ctrl + s

Ctrl + c
Finaliza o comando em execução atualmente

Ctrl + z
Suspende ou interrompe a execução do comando

Comandos Bang do Bash (reexecução de comandos):

!!
Executa novamente o último comando

!xyz
Executa novamente o comando mais recente que se inicia com os caracteres ‘xyz’

!xyz:p
Mostra o comando que !xyz iria rodar (mas sem execuá-lo), adicionando-o ao final da lista de comandos do histórico.

!$
Usar a última palavra do comando anterior (o mesmo que Alt + .)

!$:p
Mostra a palavra que a sequência !$ iria substituir, mas sem executar o comando.

Espero que esta listagem de atalhos de teclado do shell bash lhes seja útil. Até mais!

O post Lista de atalhos de teclado do Shell Bash 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.

É possível criar uma sequência de comandos a serem executados no shell Bash por meio do uso de operadores específicos.

Os operadores utilizados para conectar comandos no terminal do Linux são ;, &, &&, | e ||. Vamos estudar cada um deles na sequência:

Operador ;

Separa comandos que serão executados sequencialmente. Os comandos posteriores são executados assim que os comandos anteriores finalizarem sua execução

Exemplo – Mudar para o diretório raiz e listar seu conteúdo mostrando as permissões e a data e hora atuais no final:

cd /; ls -l; date

Operador &

Permite executar o comando em segundo plano em um subshell. Desta forma, o shell fica livre para que outros comandos sejam executados, enquanto o comando especificado roda em background.

Exemplo – Se o diretório /imagens não existir, criá-lo:

[ ! -d /imagens ] && mkdir /imagens

Exemplo 2: Copiar todos os arquivos presentes no diretório /usr e seus subdiretórios que possuam a extensão .txt para o diretório /home/fabio/Documentos, liberando o terminal imediatamente, enquanto os arquivos são copiados:

find /usr/ -name "*.txt" -exec cp {} /home/fabio/Documentos \; &

Operador &&

Separa comandos que serão executados sequencialmente. Os comandos posteriores somente são executados se os comandos anteriores forem executados com sucesso. Ou seja, um comando somente será executado se seu antecessor tiver retornado status de saída igual a zero.

Exemplo – Atualizar os pacotes instalados no sistema após efetuar atualização da lista de pacotes dos repositórios:

apt-get update && apt-get upgrade

Operador |

Permite unir a saída padrão de um comando à entrada padrão de outro comando, ou seja, redireciona a saída de um comando para a entrada de outro.

Exemplo – Filtrar todos os processos em execução no sistema que tenham relação com o shell bash:

ps -ef | grep bash

Operador ||

Os comandos posteriores são executados somente se os comandos anteriores forem executados com falha. Ou seja, um comando somente será executado se seu antecessor tiver retornado status de saída igual diferente de zero.

Exemplo – Se o diretório /arquivos não existir no sistema, criá-lo; caso contrário, não efetuar essa operação:

ls /arquivos || mkdir /arquivos

Combinando os operadores

Exemplo – Se o diretório /docs não existir no sistema, criá-lo e copiar o arquivo /etc/passwd para dentro dele; também exibir seu conteúdo para mostrar que o diretório foi criado e o arquivo copiado de acordo:

[ ! -d /docs ] || mkdir /docs && cp /etc/passwd /docs; ls /docs

É isso aí! Falaremos mais sobre o shell Bash do Linux no próximo tutorial. Até!

O post Ligando comandos no shell Bash – Linux apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.