Formatação de Texto no Linux

Introdução

A formatação de texto é uma habilidade fundamental para usuários Linux e administradores de sistema. A capacidade de apresentar dados em formatos estruturados e legíveis é essencial para criar relatórios, organizar saídas e tornar a informação mais fácil de entender.

Neste laboratório, você aprenderá a usar o comando printf, uma poderosa ferramenta de formatação de texto no Linux. Você explorará várias técnicas de formatação, incluindo alinhamento de campo, especificação de largura, formatação de números e o uso de sequências de escape. Essas habilidades o ajudarão a criar saídas bem estruturadas para scripts, processamento de dados e tarefas de administração de sistema.

Introdução aos Fundamentos do printf

O comando printf no Linux é usado para formatar e imprimir dados. Ao contrário do comando echo, mais simples, o printf oferece controle preciso sobre como seu texto aparece.

Neste passo, você aprenderá a sintaxe básica do comando printf e criará sua primeira saída formatada.

Primeiro, navegue até o diretório do seu projeto:

cd ~/project/text_formatting

A sintaxe básica do printf é:

printf "formato" argumentos

Onde:

• "formato" é uma string contendo texto e especificadores de formato
• Os especificadores de formato começam com % e definem como os argumentos devem ser formatados
• argumentos são os valores a serem formatados

Vamos criar um exemplo simples:

printf 'Olá, %s!\n' "Mundo"

Neste comando:

• %s é um especificador de formato para strings
• "Mundo" é o argumento que substitui %s
• \n adiciona uma nova linha no final

Você deve ver a saída:

Olá, Mundo!

Agora, tente usar múltiplos argumentos:

printf 'Nome: %s, Função: %s\n' "Alice" "Engenheira"

Saída:

Nome: Alice, Função: Engenheira

Vamos salvar algum texto formatado em um arquivo:

printf 'Data de hoje: %s\n' "$(date +%Y-%m-%d)" > data.txt
cat data.txt

Este comando:

1. Usa $(date +%Y-%m-%d) para obter a data atual no formato AAAA-MM-DD
2. Formata-a com printf
3. Salva a saída em um arquivo chamado data.txt
4. Exibe o conteúdo do arquivo

Formatação de Strings com Largura e Alinhamento

Ao exibir dados em colunas ou tabelas, controlar a largura e o alinhamento do texto torna-se importante. Neste passo, você aprenderá como especificar a largura do campo e o alinhamento para dados de string.

O especificador de formato para strings com controle de largura segue este padrão:
%[flags][width]s

Onde:

• [width] especifica a largura mínima do campo
• [flags] controla o alinhamento e outras opções (- para alinhamento à esquerda)

Vamos criar um arquivo com colunas formatadas:

touch formatted_names.txt
printf "%-15s %-10s %s\n" "First Name" "Last Name" "Department" >> formatted_names.txt
printf "%-15s %-10s %s\n" "John" "Smith" "Engineering" >> formatted_names.txt
printf "%-15s %-10s %s\n" "Mary" "Johnson" "Marketing" >> formatted_names.txt
printf "%-15s %-10s %s\n" "Robert" "Williams" "Finance" >> formatted_names.txt
cat formatted_names.txt

Neste exemplo:

• %-15s formata a primeira coluna como uma string alinhada à esquerda com uma largura de 15 caracteres
• %-10s formata a segunda coluna como uma string alinhada à esquerda com uma largura de 10 caracteres
• %s formata a terceira coluna como uma string padrão
• \n adiciona uma nova linha no final

A saída exibirá uma tabela organizada com colunas alinhadas:

First Name      Last Name  Department
John            Smith      Engineering
Mary            Johnson    Marketing
Robert          Williams   Finance

Para ver a diferença entre o alinhamento à esquerda e à direita, tente:

printf "Left aligned:  '%-10s'\n" "text"
printf "Right aligned: '%10s'\n" "text"

Saída:

Left aligned:  'text      '
Right aligned: '      text'

Formatação de Números e Valores Decimais

O comando printf oferece várias opções para formatar números, incluindo inteiros e valores de ponto flutuante. Neste passo, você aprenderá como controlar a exibição de dados numéricos.

Para inteiros, o especificador de formato básico é %d. Vamos criar um arquivo com números formatados:

touch numerical_data.txt
printf "Decimal: %d, Padded: %05d\n" 42 42 > numerical_data.txt
cat numerical_data.txt

Neste exemplo:

• %d exibe o número como um inteiro decimal simples
• %05d exibe o número como um inteiro decimal de 5 dígitos, preenchido com zeros à esquerda

Saída:

Decimal: 42, Padded: 00042

Para números de ponto flutuante, você pode usar %f e controlar a precisão:

printf "Float: %f, Rounded: %.2f\n" 3.14159 3.14159 >> numerical_data.txt
cat numerical_data.txt

Neste exemplo:

• %f exibe o número de ponto flutuante completo
• %.2f exibe o número de ponto flutuante arredondado para 2 casas decimais

O arquivo completo agora contém:

Decimal: 42, Padded: 00042
Float: 3.141590, Rounded: 3.14

Você também pode formatar números com diferentes sistemas numéricos:

printf "Decimal: %d, Hexadecimal: %x, Octal: %o\n" 16 16 16 >> numerical_data.txt
cat numerical_data.txt

Saída adicionada ao arquivo:

Decimal: 16, Hexadecimal: 10, Octal: 20

Utilizando Sequências de Escape

Sequências de escape no comando printf permitem que você inclua caracteres especiais e códigos de controle em seu texto formatado. Neste passo, você aprenderá como usar várias sequências de escape.

Sequências de escape comuns incluem:

• \n - Nova linha (Newline)
• \t - Tabulação (Tab)
• \" - Aspas duplas (Double quote)
• \\ - Barra invertida (Backslash)
• \b - Retrocesso (Backspace)

Vamos criar um arquivo com exemplos de sequências de escape:

touch escape_sequences.txt
printf "Lines:\nFirst line\nSecond line\n" > escape_sequences.txt
printf "Tabs:\tColumn1\tColumn2\tColumn3\n" >> escape_sequences.txt
printf "Quotes: \"quoted text\"\n" >> escape_sequences.txt
cat escape_sequences.txt

A saída mostrará como essas sequências de escape funcionam:

Lines:
First line
Second line
Tabs: Column1 Column2 Column3
Quotes: "quoted text"

O especificador de formato %b permite a interpretação de sequências de escape em argumentos:

printf "%b" "Newline: \\n becomes a\nnew line\n" >> escape_sequences.txt
cat escape_sequences.txt

O especificador %b também é útil para interpretar sequências de escape hexadecimais que representam caracteres ASCII ou Unicode:

printf "ASCII: %b\n" "\x48\x65\x6c\x6c\x6f" >> escape_sequences.txt
cat escape_sequences.txt

Saída:

ASCII: Hello

Criando um Relatório Formatado

Neste passo final, você combinará as técnicas que aprendeu para criar um relatório bem formatado. Isso demonstrará como essas habilidades de formatação podem ser aplicadas em cenários práticos.

Vamos criar um script que gera um relatório de informações do sistema:

touch system_report.sh
chmod +x system_report.sh

Abra o arquivo de script com nano:

nano system_report.sh

Adicione o seguinte conteúdo ao script:

#!/bin/bash

## Define the output file
report_file="system_report.txt"

## Clear any existing report
> $report_file

## Add formatted header
printf "=======================================\n" >> $report_file
printf "       %s        \n" "SYSTEM INFORMATION REPORT" >> $report_file
printf "       %s        \n" "Generated on: $(date)" >> $report_file
printf "=======================================\n\n" >> $report_file

## CPU Information
printf "%-15s %s\n" "CPU:" "$(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/^[ \t]*//')" >> $report_file

## Memory Information
total_mem=$(free -m | grep Mem | awk '{print $2}')
used_mem=$(free -m | grep Mem | awk '{print $3}')
printf "%-15s %d MB (Used: %d MB)\n" "Memory:" $total_mem $used_mem >> $report_file

## Disk Information
disk_info=$(df -h / | tail -1)
disk_size=$(echo $disk_info | awk '{print $2}')
disk_used=$(echo $disk_info | awk '{print $3}')
disk_percent=$(echo $disk_info | awk '{print $5}')
printf "%-15s %s (Used: %s, %s)\n" "Disk Space:" $disk_size $disk_used $disk_percent >> $report_file

## System Uptime
uptime_info=$(uptime -p)
printf "%-15s %s\n" "Uptime:" "$uptime_info" >> $report_file

## Add a table of processes
printf "\n%-6s %-10s %-8s %-6s %s\n" "PID" "USER" "CPU%" "MEM%" "COMMAND" >> $report_file
printf "%-6s %-10s %-8s %-6s %s\n" "--" "----" "----" "----" "-------" >> $report_file

## Get top 5 processes by CPU usage
ps aux --sort=-%cpu | head -6 | tail -5 | while read line; do
  pid=$(echo $line | awk '{print $2}')
  user=$(echo $line | awk '{print $1}')
  cpu=$(echo $line | awk '{print $3}')
  mem=$(echo $line | awk '{print $4}')
  cmd=$(echo $line | awk '{print $11}')
  printf "%-6s %-10s %-8.1f %-6.1f %s\n" "$pid" "$user" "$cpu" "$mem" "$cmd" >> $report_file
done

echo "Report generated: $report_file"

Salve e saia do nano (pressione Ctrl+O, depois Enter e, em seguida, Ctrl+X).

Execute o script para gerar o relatório:

./system_report.sh

Visualize o relatório gerado:

cat system_report.txt

O relatório combina várias técnicas de formatação:

• Largura de campo e alinhamento para apresentação de dados organizada
• Formatação numérica para valores de CPU e memória
• Cabeçalhos com texto centralizado
• Dados tabulares com colunas alinhadas

Este exemplo demonstra como as técnicas de formatação que você aprendeu podem ser aplicadas para criar uma saída clara e legível para relatórios de informações do sistema.

Resumo

Neste laboratório, você aprendeu como usar o comando printf para formatação de texto no Linux. Você praticou:

1. Sintaxe básica do printf e formatação de strings
2. Controlar a largura do campo e o alinhamento para uma saída tabular limpa
3. Formatar diferentes tipos de números, incluindo inteiros e valores de ponto flutuante
4. Usar sequências de escape para incluir caracteres especiais em sua saída
5. Combinar essas técnicas para criar um relatório prático de informações do sistema

Essas habilidades de formatação de texto são essenciais para criar uma saída legível em scripts de shell, gerar relatórios e organizar informações no terminal. O comando printf oferece controle preciso sobre como seu texto é exibido, tornando-o uma ferramenta poderosa para usuários Linux e administradores de sistema.

À medida que você continua sua jornada no Linux, você descobrirá que essas técnicas de formatação são valiosas para apresentar dados de forma clara e profissional em seus scripts e aplicações de linha de comando.