Edition de flux Linux

Introduction

Bienvenue dans le laboratoire sur l'édition de flux Linux. Dans ce laboratoire, vous apprendrez à utiliser sed (Stream Editor), un outil en ligne de commande puissant pour l'analyse et la transformation de texte. sed est utilisé pour effectuer des transformations de texte de base sur un flux d'entrée (un fichier ou une entrée provenant d'un pipeline).

À la fin de ce laboratoire, vous serez en mesure de :

• Effectuer des substitutions de texte de base avec sed
• Modifier des fichiers directement en utilisant sed
• Appliquer des substitutions globales sur des fichiers entiers
• Utiliser des techniques avancées de traitement de texte

Les compétences que vous acquerrez vous aideront à manipuler efficacement les fichiers et les flux de texte, ce qui est essentiel pour diverses tâches d'administration système et de traitement de texte sous Linux.

Utilisation de base de sed et substitution de texte

Dans cette étape, nous allons apprendre les bases de sed et comment effectuer des substitutions de texte simples. La commande sed est un outil puissant de traitement de texte qui vous permet de rechercher, de trouver et de remplacer, d'insérer et de supprimer du texte dans des fichiers sans les ouvrir dans un éditeur.

Tout d'abord, vérifions que sed est installé sur notre système en exécutant :

which sed

Vous devriez voir une sortie similaire à :

/usr/bin/sed

Cela confirme que sed est disponible. Si pour une raison quelconque il n'est pas installé, vous pouvez l'installer avec :

sudo apt-get update
sudo apt-get install -y sed

Maintenant, créons un fichier texte sur lequel travailler. Nous allons créer un fichier nommé sample.txt dans le répertoire actuel :

echo "Linux is a powerful operating system." > ~/project/sample.txt
echo "Many users prefer Linux for servers." >> ~/project/sample.txt
echo "Linux has strong security features." >> ~/project/sample.txt

Examinons le contenu de notre nouveau fichier :

cat ~/project/sample.txt

Vous devriez voir :

Linux is a powerful operating system.
Many users prefer Linux for servers.
Linux has strong security features.

Maintenant, utilisons sed pour effectuer une substitution de base. La commande suivante remplacera la première occurrence de "Linux" par "Ubuntu" sur chaque ligne :

sed 's/Linux/Ubuntu/' ~/project/sample.txt

Vous devriez voir :

Ubuntu is a powerful operating system.
Many users prefer Ubuntu for servers.
Ubuntu has strong security features.

Notez que sed a imprimé le texte modifié sur la sortie standard (votre terminal), mais que le fichier original reste inchangé. Vous pouvez le vérifier en exécutant :

cat ~/project/sample.txt

La sortie devrait toujours afficher "Linux" et non "Ubuntu" :

Linux is a powerful operating system.
Many users prefer Linux for servers.
Linux has strong security features.

La syntaxe de base pour la substitution avec sed est :

sed 's/pattern/replacement/' filename

Où :

• s est la commande de substitution
• pattern est le texte que vous voulez remplacer
• replacement est le nouveau texte
• filename est le fichier d'entrée

Essayons un autre exemple. Cette fois, nous allons remplacer "powerful" par "versatile" :

sed 's/powerful/versatile/' ~/project/sample.txt

Cela devrait afficher :

Linux is a versatile operating system.
Many users prefer Linux for servers.
Linux has strong security features.

Édition en place et substitution globale

Dans l'étape précédente, nous avons appris à utiliser sed pour des substitutions de texte de base, mais les modifications n'étaient affichées que sur l'écran et n'étaient pas enregistrées dans le fichier. Dans cette étape, nous allons apprendre à :

1. Modifier des fichiers en place avec l'option -i
2. Effectuer des substitutions globales en utilisant le marqueur g

Édition en place

Pour apporter des modifications permanentes à un fichier en utilisant sed, nous utilisons l'option -i. Cette option modifie directement le fichier au lieu de simplement afficher la sortie dans le terminal.

Modifions notre fichier sample.txt en remplaçant "Linux" par "Ubuntu" :

sed -i 's/Linux/Ubuntu/' ~/project/sample.txt

Contrairement à l'étape précédente, cette commande ne produit aucune sortie visible. Vérifions le contenu du fichier pour voir s'il a été modifié :

cat ~/project/sample.txt

Vous devriez maintenant voir :

Ubuntu is a powerful operating system.
Many users prefer Ubuntu for servers.
Ubuntu has strong security features.

Les modifications ont été enregistrées dans le fichier ! Voilà le pouvoir de l'édition en place avec sed.

Substitution globale

Par défaut, sed ne remplace que la première occurrence du motif sur chaque ligne. Pour remplacer toutes les occurrences, nous utilisons le marqueur g (global) à la fin de la commande de substitution.

Créons un nouveau fichier avec du texte répété :

echo "The red car stopped at the red light near the red building." > ~/project/colors.txt

Maintenant, utilisons sed sans le marqueur global pour remplacer "red" par "blue" :

sed 's/red/blue/' ~/project/colors.txt

Vous devriez voir :

The blue car stopped at the red light near the red building.

Notez que seule la première occurrence de "red" a été remplacée par "blue". Maintenant, utilisons le marqueur global :

sed 's/red/blue/g' ~/project/colors.txt

La sortie devrait être :

The blue car stopped at the blue light near the blue building.

Toutes les occurrences de "red" ont été remplacées par "blue" !

Appliquons cela à notre fichier sample.txt. Tout d'abord, ajoutons plus d'occurrences de "Ubuntu" :

echo "Ubuntu is great. I use Ubuntu daily for my work with Ubuntu tools." >> ~/project/sample.txt

Maintenant, remplaçons toutes les occurrences de "Ubuntu" par "Linux" en utilisant le marqueur global et l'édition en place :

sed -i 's/Ubuntu/Linux/g' ~/project/sample.txt

Vérifions les modifications :

cat ~/project/sample.txt

Vous devriez voir :

Linux is a powerful operating system.
Many users prefer Linux for servers.
Linux has strong security features.
Linux is great. I use Linux daily for my work with Linux tools.

Toutes les occurrences de "Ubuntu" ont été remplacées par "Linux" dans tout le fichier.

Création d'une sauvegarde avant l'édition en place

Lorsque vous utilisez l'édition en place, il est souvent recommandé de créer une sauvegarde du fichier original. Vous pouvez le faire en fournissant une extension à l'option -i :

sed -i.bak 's/Linux/Ubuntu/g' ~/project/sample.txt

Cette commande va :

1. Créer une sauvegarde de sample.txt sous le nom sample.txt.bak
2. Remplacer toutes les occurrences de "Linux" par "Ubuntu" dans sample.txt

Vérifions les deux fichiers :

cat ~/project/sample.txt
cat ~/project/sample.txt.bak

La première commande devrait montrer toutes les occurrences de "Linux" remplacées par "Ubuntu", tandis que le fichier de sauvegarde devrait toujours contenir "Linux".

Commandes avancées de sed et correspondance de motifs

Maintenant que nous maîtrisons les substitutions de base et l'édition en place avec sed, explorons quelques fonctionnalités plus avancées :

1. Utilisation de différents délimiteurs
2. Utilisation de plages d'adresses pour cibler des lignes spécifiques
3. Combinaison de plusieurs commandes

Utilisation de différents délimiteurs

Bien que nous ayons utilisé le slash / comme délimiteur dans nos commandes de substitution, sed nous permet d'utiliser n'importe quel caractère comme délimiteur. Cela est particulièrement utile lorsque le motif ou le texte de remplacement contient des slashes.

Créons un fichier avec des chemins de fichiers :

echo "/usr/local/bin is in the PATH" > ~/project/paths.txt
echo "My config is in /etc/myapp/config.json" >> ~/project/paths.txt

Si nous voulons remplacer /usr/local/bin par /opt/bin, utiliser des slashes serait confuse :

sed 's/\/usr\/local\/bin/\/opt\/bin/' ~/project/paths.txt

Au lieu de cela, nous pouvons utiliser un autre délimiteur, comme # :

sed 's#/usr/local/bin#/opt/bin#' ~/project/paths.txt

Cela est beaucoup plus lisible ! La sortie devrait être :

/opt/bin is in the PATH
My config is in /etc/myapp/config.json

D'autres délimiteurs courants incluent |, : et _.

Adressage - Ciblage de lignes spécifiques

sed nous permet de spécifier les lignes sur lesquelles appliquer la substitution. Cela se fait en préfixant la commande avec une adresse.

Créons un nouveau fichier avec des lignes numérotées :

echo "Line 1: This is the first line." > ~/project/numbered.txt
echo "Line 2: This is the second line." >> ~/project/numbered.txt
echo "Line 3: This is the third line." >> ~/project/numbered.txt
echo "Line 4: This is the fourth line." >> ~/project/numbered.txt
echo "Line 5: This is the fifth line." >> ~/project/numbered.txt

Pour remplacer "line" par "row" seulement sur la ligne 3 :

sed '3 s/line/row/' ~/project/numbered.txt

La sortie devrait être :

Line 1: This is the first line.
Line 2: This is the second line.
Line 3: This is the third row.
Line 4: This is the fourth line.
Line 5: This is the fifth line.

Nous pouvons également spécifier une plage de lignes. Pour remplacer "line" par "row" sur les lignes 2 à 4 :

sed '2,4 s/line/row/' ~/project/numbered.txt

La sortie devrait être :

Line 1: This is the first line.
Line 2: This is the second row.
Line 3: This is the third row.
Line 4: This is the fourth row.
Line 5: This is the fifth line.

Une autre fonction utile est la capacité de correspondre aux lignes en fonction d'un motif. Par exemple, pour remplacer "line" par "row" seulement sur les lignes qui contiennent "third" ou "fourth" :

sed '/\(third\|fourth\)/ s/line/row/' ~/project/numbered.txt

La sortie devrait être :

Line 1: This is the first line.
Line 2: This is the second line.
Line 3: This is the third row.
Line 4: This is the fourth row.
Line 5: This is the fifth line.

Combinaison de plusieurs commandes

Nous pouvons combiner plusieurs commandes sed en utilisant l'option -e ou en séparant les commandes par des points-virgules.

Remplaçons "first" par "1st", "second" par "2nd" et "third" par "3rd" en une seule commande :

sed -e 's/first/1st/' -e 's/second/2nd/' -e 's/third/3rd/' ~/project/numbered.txt

Alternativement, nous pouvons utiliser des points-virgules :

sed 's/first/1st/; s/second/2nd/; s/third/3rd/' ~/project/numbered.txt

Les deux commandes devraient produire la même sortie :

Line 1: This is the 1st line.
Line 2: This is the 2nd line.
Line 3: This is the 3rd line.
Line 4: This is the fourth line.
Line 5: This is the fifth line.

Rendons maintenant ces modifications permanentes :

sed -i 's/first/1st/; s/second/2nd/; s/third/3rd/' ~/project/numbered.txt

Et vérifions les modifications :

cat ~/project/numbered.txt

Vous devriez voir le texte mis à jour avec les numéros ordinaux.

Utilisation de scripts sed

Dans les étapes précédentes, nous avons exécuté des commandes sed directement depuis la ligne de commande. Cependant, pour des opérations plus complexes, il est souvent plus pratique de créer un fichier de script sed. Cela nous permet de :

1. Organiser plusieurs commandes sed
2. Ajouter des commentaires pour expliquer ce que chaque commande fait
3. Réutiliser les mêmes opérations sur différents fichiers

Création d'un script sed

Créons un simple script sed qui effectue plusieurs transformations de texte :

cat > ~/project/transform.sed << 'EOF'
## Replace "Linux" with "Ubuntu"
s/Linux/Ubuntu/g

## Replace "user" with "developer"
s/user/developer/g

## Replace "system" with "platform"
s/system/platform/g

## Convert "is" to uppercase
s/is/IS/g
EOF

Ce script effectue quatre substitutions :

1. Remplace toutes les occurrences de "Linux" par "Ubuntu"
2. Remplace toutes les occurrences de "user" par "developer"
3. Remplace toutes les occurrences de "system" par "platform"
4. Convertit toutes les occurrences de "is" en majuscules "IS"

Créons un nouveau fichier pour tester notre script :

cat > ~/project/test.txt << 'EOF'
Linux is a powerful operating system.
The user interface is very customizable.
Many Linux users prefer the command-line interface.
The system resources are efficiently managed.
EOF

Exécution d'un script sed

Pour exécuter notre script sed sur le fichier de test, nous utilisons l'option -f :

sed -f ~/project/transform.sed ~/project/test.txt

Vous devriez voir :

Ubuntu IS a powerful operating platform.
The developer interface IS very customizable.
Many Ubuntu developers prefer the command-line interface.
The platform resources are efficiently managed.

Toutes les substitutions de notre script ont été appliquées !

Édition en place avec un script

Tout comme avec les commandes sed en ligne de commande, nous pouvons utiliser l'option -i pour effectuer une édition en place avec un script :

sed -i -f ~/project/transform.sed ~/project/test.txt

Vérifions les modifications :

cat ~/project/test.txt

Le fichier devrait maintenant contenir le texte transformé.

Création d'une sauvegarde avec un script

Encore une fois, nous pouvons créer une sauvegarde avant d'apporter des modifications :

## First, let's restore the original content
cat > ~/project/test.txt << 'EOF'
Linux is a powerful operating system.
The user interface is very customizable.
Many Linux users prefer the command-line interface.
The system resources are efficiently managed.
EOF

## Now run sed with a backup
sed -i.bak -f ~/project/transform.sed ~/project/test.txt

Vérifions le fichier modifié et la sauvegarde :

cat ~/project/test.txt
cat ~/project/test.txt.bak

La première commande devrait montrer le texte transformé, tandis que le fichier de sauvegarde devrait contenir le texte original.

Application d'un script sed à plusieurs fichiers

L'un des avantages d'utiliser un script sed est que nous pouvons facilement appliquer les mêmes transformations à plusieurs fichiers.

Créons quelques autres fichiers de test :

## Create test1.txt
cat > ~/project/test1.txt << 'EOF'
Linux offers excellent system performance.
Many users appreciate its stability.
EOF

## Create test2.txt
cat > ~/project/test2.txt << 'EOF'
The Linux community provides great support.
New users can find helpful resources online.
EOF

## Create test3.txt
cat > ~/project/test3.txt << 'EOF'
The system updates are well-managed in Linux.
Users can customize their experience.
EOF

Maintenant, appliquons notre script sed à tous ces fichiers d'un coup :

sed -i -f ~/project/transform.sed ~/project/test1.txt ~/project/test2.txt ~/project/test3.txt

Vérifions les modifications :

cat ~/project/test1.txt
cat ~/project/test2.txt
cat ~/project/test3.txt

Les trois fichiers devraient montrer le texte transformé selon notre script.

Cela démontre le pouvoir des scripts sed pour le traitement par lots de plusieurs fichiers avec le même ensemble de transformations.

Résumé

Dans ce laboratoire, vous avez appris à utiliser sed, l'éditeur de flux (Stream Editor), pour manipuler des fichiers texte sous Linux. Vous avez acquis une expérience pratique sur plusieurs aspects importants de sed :

• Substitution de texte de base en utilisant la commande s
• Édition en place avec l'option -i
• Substitution globale avec le marqueur g
• Création de sauvegardes avant l'édition avec l'option -i.bak
• Utilisation de différents délimiteurs pour les motifs de substitution
• Ciblage de lignes spécifiques avec des adresses et des plages
• Création et exécution de scripts sed pour des opérations plus complexes
• Application de transformations à plusieurs fichiers d'un coup

Ces compétences sont essentielles pour un traitement efficace des textes dans les environnements Linux. La capacité à manipuler des fichiers texte sans les ouvrir dans un éditeur est particulièrement précieuse pour les administrateurs systèmes, les développeurs et les analystes de données qui ont souvent besoin de traiter de grands volumes de données textuelles ou d'apporter des modifications systématiques à travers plusieurs fichiers.

Au fur et à mesure que vous continuerez à travailler avec Linux, vous constaterez que sed est un outil indispensable dans votre boîte à outils de traitement de texte, aux côtés d'autres utilitaires tels que grep, awk et cut.