Leitura de Entrada no Linux

LinuxBeginner
Pratique Agora

Introdução

Este laboratório apresenta a leitura de entrada em scripts de shell Linux. A leitura de entrada é uma habilidade fundamental para criar scripts de shell interativos que podem responder à entrada do usuário. Ao aprender a usar o comando read, você poderá coletar e processar dados inseridos pelos usuários, tornando seus scripts mais versáteis e fáceis de usar.

Neste laboratório, você aprenderá a ler a entrada do usuário, processar essa entrada dentro de seus scripts e criar scripts de shell interativos que podem responder dinamicamente a diferentes entradas do usuário. Essas habilidades são essenciais para escrever ferramentas e scripts de linha de comando eficazes em ambientes Linux.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 96%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Leitura Básica de Entrada

O comando read é um comando de shell embutido que lê uma linha de entrada da entrada padrão (geralmente o teclado) e a atribui a variáveis. Isso permite que os scripts recebam e processem a entrada do usuário.

Nesta etapa, você criará um script simples que lê a entrada do usuário e a exibe de volta para o usuário.

  1. Primeiro, certifique-se de estar no diretório do projeto:

    cd /home/labex/project
  2. Crie um novo arquivo de script chamado input_reader.sh:

    touch input_reader.sh
  3. Torne o script executável:

    chmod +x input_reader.sh
  4. Abra o arquivo de script usando o editor de texto nano:

    nano input_reader.sh
  5. Adicione o seguinte código ao script:

    #!/bin/bash
    
    ## A simple script to demonstrate basic input reading
    echo "Please enter your name:"
    read name
    echo "Hello, $name! Welcome to Linux input reading."

    Este script:

    • Começa com um shebang (#!/bin/bash) que especifica que o script deve ser executado usando bash
    • Exibe um prompt pedindo o nome do usuário
    • Usa o comando read para capturar o que o usuário digita e armazena em uma variável chamada name
    • Exibe uma saudação que inclui o nome inserido pelo usuário
  6. Salve o arquivo pressionando Ctrl+O, depois pressione Enter para confirmar o nome do arquivo e saia do nano pressionando Ctrl+X.

  7. Execute o script para testá-lo:

    ./input_reader.sh

    Você deve ver uma saída semelhante a esta:

    Please enter your name:
    John
    Hello, John! Welcome to Linux input reading.

    A saída real exibirá qualquer nome que você inseriu em vez de "John".

O comando read aguarda a entrada do usuário e a armazena em uma ou mais variáveis. Neste exemplo, a entrada foi armazenada em uma única variável chamada name. Mais tarde, você aprenderá como capturar várias entradas com um único comando read.

Usando Read com Loops

Nesta etapa, você aprimorará seu script para ler continuamente as entradas usando um loop até que uma condição de saída específica seja atendida. Esse padrão é comumente usado em scripts interativos onde você precisa coletar várias informações do usuário.

  1. Abra seu script para edição:

    nano input_reader.sh
  2. Substitua o conteúdo existente pelo seguinte código:

    #!/bin/bash
    
    ## Enhanced script with a loop for multiple inputs
    echo "Enter multiple inputs (type 'exit' to quit):"
    
    while true; do
      ## Prompt for input
      echo -n "> "
      read input
    
      ## Check if user wants to exit
      if [[ "$input" == "exit" ]]; then
        echo "Exiting the input reader."
        break
      fi
    
      ## Process the input
      echo "You entered: $input"
    done
    
    echo "Thank you for using the input reader!"

    Este script:

    • Usa um loop while true para criar um loop infinito que continuará aceitando entradas
    • Exibe um prompt (>) antes de cada entrada usando echo -n, o que impede uma nova linha
    • Lê a entrada do usuário na variável input
    • Verifica se a entrada é "exit" e sai do loop se for
    • Caso contrário, ele ecoa a entrada de volta para o usuário
    • Finalmente, exibe uma mensagem de agradecimento após sair do loop
  3. Salve o arquivo pressionando Ctrl+O, depois pressione Enter para confirmar o nome do arquivo e saia do nano pressionando Ctrl+X.

  4. Execute o script aprimorado:

    ./input_reader.sh

    Você deve ver uma saída semelhante a esta:

    Enter multiple inputs (type 'exit' to quit):
    > hello
    You entered: hello
    > world
    You entered: world
    > exit
    Exiting the input reader.
    Thank you for using the input reader!

Essa estrutura de loop é particularmente útil quando você precisa processar várias entradas sequencialmente, como ao construir uma interface de linha de comando simples ou uma ferramenta de entrada de dados. A instrução break é usada para sair do loop quando o usuário digita "exit", mas você pode modificar a condição para sair com base em qualquer critério que você precisar.

Leitura com Prompts e Valores Padrão

Nesta etapa, você aprenderá como fornecer valores padrão para entrada e usar a opção -p para criar prompts mais limpos. Isso é útil quando você deseja dar aos usuários a opção de simplesmente pressionar Enter para aceitar um valor sugerido.

  1. Abra seu script para edição:

    nano input_reader.sh
  2. Substitua o conteúdo existente pelo seguinte código:

    #!/bin/bash
    
    ## Script demonstrating read with default values
    
    ## Using -p flag for prompt and providing default with || operator
    read -p "Enter your country (default: USA): " country
    country=${country:-USA}
    echo "Country set to: $country"
    
    ## Another example with a default value
    read -p "Enter your preferred programming language (default: Bash): " language
    language=${language:-Bash}
    echo "Programming language set to: $language"
    
    ## Combining with a timeout using -t option
    echo "Quick response needed:"
    read -t 5 -p "What is your favorite color? (You have 5 seconds, default: Blue): " color
    color=${color:-Blue}
    echo "Favorite color set to: $color"

    Este script:

    • Usa a flag -p para exibir um prompt dentro do mesmo comando read, tornando o código mais conciso
    • Aplica a sintaxe ${variable:-default} para definir um valor padrão se a entrada do usuário estiver vazia
    • Demonstra a opção -t, que define um tempo limite para a entrada (5 segundos neste exemplo)
  3. Salve o arquivo pressionando Ctrl+O, depois pressione Enter para confirmar o nome do arquivo e saia do nano pressionando Ctrl+X.

  4. Execute o script para testá-lo:

    ./input_reader.sh

    Experimente estes cenários:

    • Insira o nome de um país quando solicitado e, em seguida, pressione Enter
    • Apenas pressione Enter (sem digitar nada) para aceitar o valor padrão
    • Para o exemplo de tempo limite, tente esperar mais de 5 segundos para ver o que acontece

    Exemplo de saída ao aceitar valores padrão:

    Enter your country (default: USA):
    Country set to: USA
    Enter your preferred programming language (default: Bash):
    Programming language set to: Bash
    Quick response needed:
    What is your favorite color? (You have 5 seconds, default: Blue):
    Favorite color set to: Blue

A opção -p para read permite que você forneça um prompt no mesmo comando, tornando seus scripts mais limpos e mais legíveis. A sintaxe ${variable:-default} é um recurso poderoso do shell que substitui um valor padrão quando a variável não está definida ou está vazia, o que é perfeito para fornecer opções padrão em scripts.

Leitura de Entrada Segura e Múltiplas Variáveis

Nesta etapa final, você aprenderá duas técnicas mais avançadas:

  1. Ler entrada segura (como senhas) sem exibir os caracteres na tela

  2. Ler múltiplas variáveis com um único comando read

  3. Abra seu script para edição:

    nano input_reader.sh
  4. Substitua o conteúdo existente pelo seguinte código:

    #!/bin/bash
    
    ## Script demonstrating secure input and multiple variable reading
    
    ## Secure input reading with -s flag (no echo)
    echo "Secure Input Example:"
    read -p "Username: " username
    read -s -p "Password: " password
    echo ## Add a newline after password input
    echo "Username entered: $username"
    echo "Password length: ${#password} characters"
    
    ## Reading multiple variables at once
    echo -e "\nMultiple Variable Example:"
    read -p "Enter first name, last name, and age (separated by spaces): " first_name last_name age
    
    echo "First name: $first_name"
    echo "Last name: $last_name"
    echo "Age: $age"
    
    ## Reading with a custom delimiter
    echo -e "\nCustom Delimiter Example:"
    read -p "Enter comma-separated values: " -d "," value1
    echo ## Add a newline
    echo "First value before comma: $value1"
    
    echo -e "\nThank you for completing this lab on Linux input reading!"

    Este script:

    • Usa a flag -s com read para ocultar a entrada (útil para senhas ou outras informações confidenciais)
    • Mostra como ler múltiplas variáveis de uma única linha de entrada, fornecendo vários nomes de variáveis ao comando read
    • Demonstra a flag -d para especificar um delimitador personalizado (em vez do caractere de nova linha padrão)
  5. Salve o arquivo pressionando Ctrl+O, depois pressione Enter para confirmar o nome do arquivo e saia do nano pressionando Ctrl+X.

  6. Execute o script para testá-lo:

    ./input_reader.sh

    Exemplo de saída (suas entradas serão diferentes):

    Secure Input Example:
    Username: john_doe
    Password:
    Username entered: john_doe
    Password length: 8 characters
    
    Multiple Variable Example:
    Enter first name, last name, and age (separated by spaces): John Doe 30
    First name: John
    Last name: Doe
    Age: 30
    
    Custom Delimiter Example:
    Enter comma-separated values: test,
    First value before comma: test
    
    Thank you for completing this lab on Linux input reading!

A segurança é importante ao lidar com informações confidenciais, como senhas. A flag -s garante que os caracteres digitados não sejam exibidos na tela. Observe que, no exemplo da senha, o script mostra apenas o comprimento da senha para verificação, não a senha real.

Ler múltiplas variáveis de uma vez pode tornar seus scripts mais eficientes e fáceis de usar. Quando o comando read recebe vários nomes de variáveis, ele divide a entrada com base na variável de ambiente IFS (Internal Field Separator), que, por padrão, é espaço em branco (espaços, tabulações e novas linhas).

A flag -d permite que você altere o delimitador que sinaliza o final da entrada. Por padrão, read para em uma nova linha (quando você pressiona Enter), mas você pode alterá-lo para qualquer caractere, como uma vírgula no exemplo.

Resumo

Neste laboratório, você aprendeu técnicas-chave para ler e processar a entrada do usuário em scripts bash do Linux:

  1. Leitura Básica de Entrada: Usando o comando read para capturar a entrada do usuário em variáveis.

  2. Entrada Baseada em Loop: Implementando loops para ler continuamente a entrada até que uma condição específica seja atendida.

  3. Valores Padrão e Prompts: Definindo valores padrão para entrada e criando scripts mais limpos com prompts embutidos.

  4. Técnicas Avançadas: Lendo entrada segura sem exibi-la na tela, capturando múltiplas variáveis em um único comando e usando delimitadores personalizados.

Essas habilidades de leitura de entrada são fundamentais para criar scripts de shell interativos que podem se adaptar à entrada do usuário, fornecer padrões apropriados e lidar com vários tipos de dados. Agora você pode aplicar essas técnicas para criar ferramentas e scripts de linha de comando mais responsivos e fáceis de usar.

À medida que você continua a desenvolver suas habilidades no Linux, considere combinar esses métodos de leitura de entrada com outros recursos do bash, como instruções condicionais, funções e operações de arquivo, para criar ferramentas mais complexas e poderosas para automação e gerenciamento de sistemas.