Mise en colonnes de texte sous Linux

Introduction

La colonisation de texte est une technique puissante sous Linux qui vous permet d'organiser et d'afficher des données dans un format tabulaire structuré. Lorsque vous travaillez avec des fichiers texte simples contenant des données délimitées, le contenu peut être difficile à lire sans un formatage approprié. La commande column sous Linux résout ce problème en transformant le texte brut en colonnes bien formatées.

Ce labo (LabEx) vous guidera dans la maîtrise de l'utilitaire column sous Linux. Vous apprendrez à afficher le contenu des fichiers dans un format tabulaire, rendant les données plus faciles à lire et à analyser. Ces compétences sont essentielles pour le traitement et la visualisation des données dans l'environnement de ligne de commande.

Skills Graph

Comprendre les bases de la commande Column

Dans cette étape, nous allons apprendre à utiliser la commande column pour formater le texte en colonnes alignées, rendant les données plus faciles à lire et à interpréter.

La commande column est un utilitaire sous Linux qui formate son entrée en plusieurs colonnes. Cela est particulièrement utile lorsqu'il s'agit de données qui ont une structure naturelle mais sont stockées au format texte brut.

Création d'un fichier de données d'exemple

Commençons par créer un simple fichier texte contenant les données que nous souhaitons formater. Nous allons créer un fichier nommé powers_list.txt dans le répertoire ~/project contenant les noms de super-pouvoirs et les noms des héros correspondants, séparés par un deux-points.

Accédez au répertoire du projet :

cd ~/project

Maintenant, créez le fichier d'exemple en utilisant la commande echo avec l'option -e, qui permet l'interprétation des caractères d'échappement (comme \n pour un saut de ligne) :

echo -e "Telekinesis:Jane\nInvisibility:John\nSuper Strength:Max" > ~/project/powers_list.txt

Examinons le contenu du fichier que nous venons de créer :

cat ~/project/powers_list.txt

Vous devriez voir une sortie comme celle-ci :

Telekinesis:Jane
Invisibility:John
Super Strength:Max

Ces données sont formatées avec un deux-points (:) comme délimiteur entre le nom du super-pouvoir et le nom du héros. Le format n'est pas très lisible tel quel.

Utilisation de la commande Column pour le formatage

Maintenant, utilisons la commande column pour transformer ces données en un format plus lisible :

column -t -s ':' ~/project/powers_list.txt

Dans cette commande :

• column est l'utilitaire que nous utilisons
• L'option -t indique à la commande de créer une sortie semblable à un tableau
• -s ':' spécifie que le délimiteur (séparateur) dans notre fichier d'entrée est un deux-points
• ~/project/powers_list.txt est le chemin vers notre fichier d'entrée

Après avoir exécuté cette commande, vous devriez voir la sortie suivante :

Telekinesis     Jane
Invisibility    John
Super Strength  Max

Remarquez comment les données sont maintenant soigneusement alignées en colonnes, ce qui les rend beaucoup plus faciles à lire. La commande column a automatiquement déterminé la largeur de chaque colonne en fonction du contenu et a aligné tout en conséquence.

Cette utilisation de base de la commande column démontre son efficacité pour formater des données textuelles afin d'améliorer leur lisibilité.

Mise en forme avancée en colonnes avec un script shell

Dans cette étape, nous allons créer un script shell qui facilite la mise en colonnes de fichiers texte avec différents délimiteurs. Cette approche offre plus de flexibilité et d'efficacité lors de la manipulation de divers formats de données.

Comprendre les scripts shell

Un script shell est un fichier contenant des commandes que le shell peut exécuter. Il vous permet d'automatiser des tâches en combinant plusieurs commandes et en ajoutant de la logique. Dans ce cas, nous allons créer un script qui simplifie le processus de mise en colonnes de fichiers.

Création du script de mise en colonnes

Créons un script nommé columnize.sh dans le répertoire ~/project. Ce script prendra deux arguments : un nom de fichier et un caractère délimiteur.

Tout d'abord, accédez au répertoire du projet si vous n'y êtes pas déjà :

cd ~/project

Maintenant, créez le fichier de script :

touch columnize.sh

Ensuite, ouvrez le fichier avec l'éditeur de texte nano :

nano columnize.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## Un script pour mettre en colonnes des fichiers texte

## Vérifier si le nombre correct d'arguments est fourni
if [ "$#" -ne 2 ]; then
  echo "Usage: $0 <filename> <delimiter>"
  echo "Example: $0 data.txt :"
  exit 1
fi

## Extraire les arguments
FILENAME=$1
DELIMITER=$2

## Vérifier si le fichier existe
if [ ! -f "$FILENAME" ]; then
  echo "Error: File '$FILENAME' does not exist"
  exit 1
fi

## Formater et afficher le contenu
column -t -s "$DELIMITER" "$FILENAME"

Pour enregistrer le fichier dans nano, appuyez sur Ctrl+O, puis sur Entrée, et pour quitter nano, appuyez sur Ctrl+X.

Analysons ce que fait ce script :

1. La première ligne (#!/bin/bash) indique au système d'utiliser le shell bash pour exécuter le script.
2. Nous vérifions si exactement deux arguments ont été fournis (un nom de fichier et un délimiteur).
3. Nous assignons ces arguments à des variables pour une référence plus facile.
4. Nous vérifions si le fichier spécifié existe.
5. Enfin, nous utilisons la commande column avec le nom de fichier et le délimiteur fournis.

Rendre le script exécutable

Avant de pouvoir utiliser notre script, nous devons le rendre exécutable :

chmod +x ~/project/columnize.sh

Utilisation du script de mise en colonnes

Maintenant, nous pouvons utiliser notre script pour mettre en colonnes des fichiers texte. Utilisons-le avec notre fichier powers_list.txt existant :

~/project/columnize.sh ~/project/powers_list.txt :

Vous devriez voir la sortie suivante :

Telekinesis     Jane
Invisibility    John
Super Strength  Max

Créons un autre fichier d'exemple avec un délimiteur différent pour tester la flexibilité de notre script :

echo -e "Apple,Red,Fruit\nCarrot,Orange,Vegetable\nBlueberry,Blue,Fruit" > ~/project/foods.txt

Utilisons maintenant notre script avec ce nouveau fichier et une virgule comme délimiteur :

~/project/columnize.sh ~/project/foods.txt ,

Vous devriez voir une sortie comme celle-ci :

Apple      Red     Fruit
Carrot     Orange  Vegetable
Blueberry  Blue    Fruit

Notre script a réussi à mettre en colonnes les données des deux fichiers, en utilisant différents délimiteurs. Cela démontre la flexibilité et la puissance de la combinaison d'un script shell avec l'utilitaire column.

Travailler avec différents formats de fichiers

Dans cette étape, nous allons explorer comment utiliser la commande column avec divers formats de fichiers et délimiteurs. Cela vous aidera à comprendre la polyvalence de l'utilitaire column et comment il peut être appliqué à différents types de données.

Travailler avec des fichiers CSV

Les fichiers CSV (Comma-Separated Values, valeurs séparées par des virgules) sont un format courant pour stocker des données tabulaires. Créons un fichier CSV plus complexe et utilisons la commande column pour le formater.

Tout d'abord, créons un nouveau fichier CSV :

cd ~/project
echo -e "Name,Age,Occupation,City\nAlex,28,Engineer,Boston\nSamantha,35,Teacher,Chicago\nMohamed,42,Doctor,New York\nLin,31,Artist,San Francisco" > employees.csv

Examinons le contenu de ce fichier :

cat employees.csv

Vous devriez voir :

Name,Age,Occupation,City
Alex,28,Engineer,Boston
Samantha,35,Teacher,Chicago
Mohamed,42,Doctor,New York
Lin,31,Artist,San Francisco

Maintenant, utilisons la commande column pour formater ce fichier CSV :

column -t -s ',' employees.csv

La sortie devrait ressembler à ceci :

Name       Age  Occupation  City
Alex       28   Engineer    Boston
Samantha   35   Teacher     Chicago
Mohamed    42   Doctor      New York
Lin        31   Artist      San Francisco

Remarquez comment la commande column a arrangé soigneusement les données en colonnes alignées, les rendant beaucoup plus faciles à lire.

Travailler avec des fichiers TSV

Le format TSV (Tab-Separated Values, valeurs séparées par des tabulations) est un autre format courant pour les données tabulaires. Créons un fichier TSV et formattons-le en utilisant la commande column.

Créons un fichier TSV :

echo -e "Product\tPrice\tCategory\nLaptop\t999.99\tElectronics\nBook\t12.50\tMedia\nChair\t149.50\tFurniture" > products.tsv

Regardons le contenu :

cat products.tsv

Vous devriez voir :

Product	Price	Category
Laptop	999.99	Electronics
Book	12.50	Media
Chair	149.50	Furniture

Maintenant, formattons-le en utilisant la commande column. Comme les tabulations sont le délimiteur par défaut pour la commande column, nous n'avons pas besoin de spécifier de délimiteur :

column -t products.tsv

La sortie devrait ressembler à :

Product  Price   Category
Laptop   999.99  Electronics
Book     12.50   Media
Chair    149.50  Furniture

Utilisation de notre script avec différents fichiers

Maintenant, utilisons notre script columnize.sh avec ces différents fichiers :

Pour le fichier CSV :

~/project/columnize.sh employees.csv ,

Pour le fichier TSV :

~/project/columnize.sh products.tsv $'\t'

Notez que dans la deuxième commande, nous utilisons $'\t' pour représenter un caractère de tabulation. Il s'agit d'une syntaxe spéciale en bash qui nous permet d'inclure des caractères spéciaux comme les tabulations.

Les deux commandes devraient produire une sortie bien formatée, démontrant la flexibilité de notre script avec différents formats de fichiers et délimiteurs.

Cette étape a montré comment la commande column et notre script peuvent être utilisés pour formater différents types de données tabulaires, les rendant plus lisibles et plus faciles à analyser.

Résumé

Dans ce laboratoire (lab), vous avez appris à utiliser la commande column pour organiser et afficher des données au format tabulaire, les rendant plus faciles à lire et à analyser. Voici un résumé de ce que vous avez accompli :

1. Vous avez appris l'utilisation de base de la commande column avec les options -t et -s pour formater des fichiers texte délimités.

2. Vous avez créé un script shell (columnize.sh) qui permet facilement d'appliquer la mise en colonnes à n'importe quel fichier avec n'importe quel délimiteur.

3. Vous avez appliqué ces techniques à différents formats de fichiers (CSV et TSV), démontrant la flexibilité de l'utilitaire column pour différents types de données.

Ces compétences sont précieuses pour le traitement et l'analyse de données dans un environnement Linux. La capacité à formater rapidement et à visualiser des données textuelles est un outil puissant pour les administrateurs système, les analystes de données et toute personne travaillant avec des fichiers texte en ligne de commande.

Les techniques que vous avez apprises peuvent être appliquées à :

• L'analyse de fichiers de logs
• La gestion de fichiers de configuration
• L'extraction et la transformation de données
• La visualisation rapide de données structurées

En maîtrisant la commande column et en apprenant à automatiser son utilisation avec des scripts shell, vous avez ajouté un outil important à votre boîte à outils de la ligne de commande Linux.