Mise en forme de texte sous Linux

Introduction

La mise en forme de texte est une compétence fondamentale pour les utilisateurs Linux et les administrateurs système. La capacité à présenter des données dans des formats structurés et lisibles est essentielle pour créer des rapports, organiser la sortie et faciliter la compréhension de l'information.

Dans ce lab (atelier), vous apprendrez à utiliser la commande printf, un outil puissant de mise en forme de texte sous Linux. Vous explorerez diverses techniques de mise en forme, notamment l'alignement des champs, la spécification de la largeur, la mise en forme des nombres et l'utilisation de séquences d'échappement. Ces compétences vous aideront à créer une sortie bien structurée pour les scripts, le traitement des données et les tâches d'administration système.

Introduction aux bases de printf

La commande printf sous Linux est utilisée pour formater et afficher des données. Contrairement à la commande plus simple echo, printf vous permet de contrôler précisément l'apparence de votre texte.

Dans cette étape, vous apprendrez la syntaxe de base de la commande printf et créerez votre première sortie formatée.

Tout d'abord, accédez à votre répertoire de projet :

cd ~/project/text_formatting

La syntaxe de base de printf est la suivante :

printf "format" arguments

Où :

• "format" est une chaîne de caractères contenant du texte et des spécificateurs de format
• Les spécificateurs de format commencent par % et définissent la manière dont les arguments doivent être formatés
• Les arguments sont les valeurs à formater

Créons un exemple simple :

printf "Hello, %s!\n" "World"

Dans cette commande :

• %s est un spécificateur de format pour les chaînes de caractères
• "World" est l'argument qui remplace %s
• \n ajoute une nouvelle ligne à la fin

Vous devriez voir la sortie suivante :

Hello, World!

Maintenant, essayez d'utiliser plusieurs arguments :

printf "Name: %s, Role: %s\n" "Alice" "Engineer"

Sortie :

Name: Alice, Role: Engineer

Enregistrons du texte formaté dans un fichier :

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

Cette commande :

1. Utilise $(date +%Y-%m-%d) pour obtenir la date actuelle au format YYYY-MM-DD
2. La formate avec printf
3. Enregistre la sortie dans un fichier nommé date.txt
4. Affiche le contenu du fichier

Mise en forme de chaînes de caractères avec largeur et alignement

Lorsque vous affichez des données en colonnes ou en tableaux, il devient important de contrôler la largeur et l'alignement du texte. Dans cette étape, vous apprendrez à spécifier la largeur du champ et l'alignement pour les données de type chaîne de caractères.

Le spécificateur de format pour les chaînes de caractères avec contrôle de la largeur suit ce modèle :
%[flags][width]s

Où :

• [width] spécifie la largeur minimale du champ
• [flags] contrôle l'alignement et d'autres options (- pour l'alignement à gauche)

Créons un fichier avec des colonnes formatées :

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

Dans cet exemple :

• %-15s formate la première colonne comme une chaîne de caractères alignée à gauche avec une largeur de 15 caractères
• %-10s formate la deuxième colonne comme une chaîne de caractères alignée à gauche avec une largeur de 10 caractères
• %s formate la troisième colonne comme une chaîne de caractères standard
• \n ajoute une nouvelle ligne à la fin

La sortie affichera un tableau bien organisé avec des colonnes alignées :

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

Pour voir la différence entre l'alignement à gauche et l'alignement à droite, essayez :

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

Sortie :

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

Mise en forme de nombres et de valeurs décimales

La commande printf propose diverses options pour la mise en forme de nombres, y compris les entiers et les valeurs à virgule flottante. Dans cette étape, vous apprendrez à contrôler l'affichage des données numériques.

Pour les entiers, le spécificateur de format de base est %d. Créons un fichier avec des nombres formatés :

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

Dans cet exemple :

• %d affiche le nombre sous forme d'entier décimal simple
• %05d affiche le nombre sous forme d'entier décimal sur 5 chiffres, complété par des zéros à gauche

Sortie :

Decimal: 42, Padded: 00042

Pour les nombres à virgule flottante, vous pouvez utiliser %f et contrôler la précision :

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

Dans cet exemple :

• %f affiche le nombre à virgule flottante en entier
• %.2f affiche le nombre à virgule flottante arrondi à 2 décimales

Le fichier complet contient maintenant :

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

Vous pouvez également formater des nombres avec différents systèmes numériques :

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

Sortie ajoutée au fichier :

Decimal: 16, Hexadecimal: 10, Octal: 20

Utilisation des séquences d'échappement

Les séquences d'échappement dans la commande printf vous permettent d'inclure des caractères spéciaux et des codes de contrôle dans votre texte formaté. Dans cette étape, vous apprendrez à utiliser diverses séquences d'échappement.

Les séquences d'échappement courantes incluent :

• \n - Saut de ligne
• \t - Tabulation
• \" - Guillemet double
• \\ - Antislash
• \b - Retour arrière

Créons un fichier avec des exemples de séquences d'échappement :

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

La sortie montrera comment ces séquences d'échappement fonctionnent :

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

Le spécificateur de format %b permet l'interprétation des séquences d'échappement dans les arguments :

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

Le spécificateur %b est également utile pour interpréter les séquences d'échappement hexadécimales qui représentent des caractères ASCII ou Unicode :

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

Sortie :

ASCII: Hello

Création d'un rapport formaté

Dans cette étape finale, vous allez combiner les techniques que vous avez apprises pour créer un rapport bien formaté. Cela montrera comment ces compétences en matière de mise en forme peuvent être appliquées dans des scénarios pratiques.

Créons un script qui génère un rapport d'informations système :

touch system_report.sh
chmod +x system_report.sh

Ouvrez le fichier du script avec nano :

nano system_report.sh

Ajoutez le contenu suivant au 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"

Enregistrez et quittez nano (appuyez sur Ctrl+O, puis Entrée, puis Ctrl+X).

Exécutez le script pour générer le rapport :

./system_report.sh

Affichez le rapport généré :

cat system_report.txt

Le rapport combine diverses techniques de mise en forme :

• Largeur de champ et alignement pour une présentation organisée des données
• Mise en forme numérique pour les valeurs de CPU et de mémoire
• En-têtes avec texte centré
• Données tabulaires avec colonnes alignées

Cet exemple montre comment les techniques de mise en forme que vous avez apprises peuvent être appliquées pour créer une sortie claire et lisible pour la génération de rapports d'informations système.

Résumé

Dans ce laboratoire (lab), vous avez appris à utiliser la commande printf pour la mise en forme de texte sous Linux. Vous avez pratiqué :

1. La syntaxe de base de printf et la mise en forme de chaînes de caractères
2. Le contrôle de la largeur de champ et de l'alignement pour obtenir une sortie tabulaire propre
3. La mise en forme de différents types de nombres, y compris les entiers et les valeurs à virgule flottante
4. L'utilisation de séquences d'échappement pour inclure des caractères spéciaux dans votre sortie
5. La combinaison de ces techniques pour créer un rapport pratique d'informations système

Ces compétences en matière de mise en forme de texte sont essentielles pour créer une sortie lisible dans les scripts shell, générer des rapports et organiser les informations dans le terminal. La commande printf vous donne un contrôle précis sur la présentation de votre texte, ce qui en fait un outil puissant pour les utilisateurs Linux et les administrateurs système.

Au fur et à mesure de votre progression dans le monde Linux, vous trouverez ces techniques de mise en forme précieuses pour présenter des données de manière claire et professionnelle dans vos scripts et applications en ligne de commande.