Les 50 exemples pratiques de la commande SED sous Linux

Que vous soyez un administrateur système ou un simple passionné, il est probable que vous ayez souvent besoin de travailler avec des documents texte. Linux, comme les autres Unix, fournit certains des meilleurs utilitaires de manipulation de texte pour les utilisateurs finaux. L'utilitaire de ligne de commande sed est l'un de ces outils qui rend le traitement de texte beaucoup plus pratique et productif. Si vous êtes un utilisateur chevronné, vous devriez déjà connaître sed. Cependant, les débutants ont souvent le sentiment que l'apprentissage de sed nécessite un travail supplémentaire et s'abstiennent donc d'utiliser cet outil fascinant. C'est pourquoi nous avons pris la liberté de produire ce guide et de les aider à apprendre les bases de sed aussi facilement que possible.

Commandes SED utiles pour les utilisateurs débutants

Sed est l'un des trois utilitaires de filtrage largement utilisés disponibles sous Unix, les autres étant "grep et awk". Nous avons déjà couvert la commande Linux grep et la commande awk pour les débutants. Ce guide vise à résumer l'utilitaire sed pour les utilisateurs novices et à les rendre aptes au traitement de texte sous Linux et d'autres Unices.

Fonctionnement du SED :compréhension de base

Avant de plonger directement dans les exemples, vous devez avoir une compréhension concise du fonctionnement général de sed. Sed est un éditeur de flux, construit au-dessus de l'utilitaire ed. Il nous permet d'apporter des modifications d'édition à un flux de données textuelles. Bien que nous puissions utiliser un certain nombre d'éditeurs de texte Linux pour l'édition, sed permet quelque chose de plus pratique.

Vous pouvez utiliser sed pour transformer du texte ou filtrer des données essentielles à la volée. Il adhère à la philosophie de base d'Unix en exécutant très bien cette tâche spécifique. De plus, sed fonctionne très bien avec les outils et commandes de terminal Linux standard. Ainsi, il est plus adapté à de nombreuses tâches que les éditeurs de texte traditionnels.

À la base, sed prend certaines entrées, effectue certaines manipulations et recrache la sortie. Il ne change pas l'entrée mais affiche simplement le résultat dans la sortie standard. Nous pouvons facilement rendre ces modifications permanentes en redirection d'E/S ou en modifiant le fichier d'origine. La syntaxe de base d'une commande sed est illustrée ci-dessous.

sed [OPTIONS] INPUTsed 'liste des commandes ed' nom de fichier

La première ligne est la syntaxe indiquée dans le manuel sed. La seconde est plus facile à comprendre. Ne vous inquiétez pas si vous n'êtes pas familier avec les commandes ed en ce moment. Vous les apprendrez tout au long de ce guide.

1. Remplacement de la saisie de texte

- -

La commande substitut est la fonctionnalité la plus largement utilisée de sed pour de nombreux utilisateurs. Il nous permet de remplacer une portion de texte par d'autres données. Vous utiliserez très souvent cette commande pour traiter des données textuelles. Cela fonctionne comme suit.

$ echo 'Bonjour le monde !' | sed 's/monde/univers/'

Cette commande affichera la chaîne "Hello Universe!". Il comporte quatre parties de base. Les 's' commande indique l'opération de substitution, /../../ sont des délimiteurs, la première partie des délimiteurs est le modèle qui doit être modifié et la dernière partie est la chaîne de remplacement.

2. Remplacement de l'entrée de texte à partir de fichiers

Créons d'abord un fichier en utilisant ce qui suit.

$ echo 'champs de fraises pour toujours...'>> fichier-entrée$ cat fichier-entrée

Maintenant, disons que nous voulons remplacer la fraise par la myrtille. Nous pouvons le faire en utilisant la commande simple suivante. Notez les similitudes entre la partie sed de cette commande et celle ci-dessus.

fichier d'entrée $ sed 's/fraise/myrtille/'

Nous avons simplement ajouté le nom du fichier après la partie sed. Vous pouvez également afficher d'abord le contenu du fichier, puis utiliser sed pour modifier le flux de sortie, comme indiqué ci-dessous.

$ cat fichier_d'entrée | sed 's/fraise/myrtille/'

3. Enregistrement des modifications apportées aux fichiers

Comme nous l'avons déjà mentionné, sed ne modifie pas du tout les données d'entrée. Il affiche simplement les données transformées sur la sortie standard, qui se trouve être le terminal Linux par défaut. Vous pouvez le vérifier en exécutant la commande suivante.

fichier d'entrée $ cat

Cela affichera le contenu original du fichier. Cependant, supposons que vous souhaitiez rendre vos modifications permanentes. Vous pouvez le faire de plusieurs façons. La méthode standard consiste à rediriger votre sortie sed vers un autre fichier. La commande suivante enregistre la sortie de la commande sed précédente dans un fichier nommé output-file.

$ sed 's/strawberry/blueberry/' fichier-entrée>> fichier-sortie

Vous pouvez le vérifier en utilisant la commande suivante.

fichier de sortie $ cat

4. Enregistrement des modifications dans le fichier d'origine

Et si vous vouliez enregistrer la sortie de sed dans le fichier d'origine ? Il est possible de le faire en utilisant le -i ou –sur place option de cet outil. Les commandes ci-dessous le démontrent à l'aide d'exemples appropriés.

$ sed -i 's/strawberry/blueberry' input-file$ sed --in-place 's/strawberry/blueberry/' input-file

Ces deux commandes ci-dessus sont équivalentes et réécrivent les modifications apportées par sed dans le fichier d'origine. Cependant, si vous envisagez de rediriger la sortie vers le fichier d'origine, cela ne fonctionnera pas comme prévu.

$ sed 's/fraise/myrtille/' fichier-entrée> fichier-entrée

Cette commande ne fonctionnera pas et aboutit à un fichier d'entrée vide. En effet, le shell effectue la redirection avant d'exécuter la commande elle-même.

5. Échappement des délimiteurs

De nombreux exemples sed conventionnels utilisent le caractère ‘/’ comme délimiteurs. Cependant, que se passe-t-il si vous souhaitez remplacer une chaîne contenant ce caractère ? L'exemple ci-dessous illustre comment remplacer un chemin de nom de fichier à l'aide de sed. Nous devrons échapper les délimiteurs ‘/’ en utilisant le caractère barre oblique inverse.

$ echo '/usr/local/bin/dummy'>> input-file$ sed 's/\/usr\/local\/bin\/dummy/\/usr\/bin\/dummy/' entrée -file> fichier de sortie

Un autre moyen facile d'échapper aux délimiteurs consiste à utiliser un métacaractère différent. Par exemple, nous pourrions utiliser '_' au lieu de '/' comme délimiteurs de la commande de substitution. C'est parfaitement valide puisque sed n'impose aucun délimiteur spécifique. Le ‘/’ est utilisé par convention, pas comme une exigence.

fichier d'entrée $ sed 's_/usr/local/bin/dummy_/usr/bin/dummy/_'

6. Remplacer chaque instance d'une chaîne

Une caractéristique intéressante de la commande de substitution est que, par défaut, elle ne remplacera qu'une seule instance d'une chaîne sur chaque ligne.

$ cat <> fichier-entrée un deux un troisdeux quatre deuxtrois un quatreEOF

Cette commande remplacera le contenu du fichier d'entrée par des nombres aléatoires dans un format de chaîne. Maintenant, regardez la commande ci-dessous.

fichier d'entrée $ sed 's/one/ONE/'

Comme vous devriez le voir, cette commande ne remplace que la première occurrence de "un" dans la première ligne. Vous devez utiliser la substitution globale pour remplacer toutes les occurrences d'un mot à l'aide de sed. Ajoutez simplement un ‘g’ après le délimiteur final de  's ‘.

fichier d'entrée $ sed 's/one/ONE/g'

Cela remplacera toutes les occurrences du mot "un" dans le flux d'entrée.

7. Utilisation de la chaîne correspondante

Parfois, les utilisateurs peuvent vouloir ajouter certaines choses comme des parenthèses ou des guillemets autour d'une chaîne spécifique. C'est facile à faire si vous savez exactement ce que vous cherchez. Cependant, que se passe-t-il si nous ne savons pas exactement ce que nous allons trouver ? L'utilitaire sed fournit une petite fonctionnalité intéressante pour faire correspondre une telle chaîne.

$ echo 'un deux trois 123' | sed 's/123/(123)/'

Ici, nous ajoutons des parenthèses autour du 123 en utilisant la commande de substitution sed. Cependant, nous pouvons le faire pour n'importe quelle chaîne de notre flux d'entrée en utilisant le métacaractère spécial & , comme illustré par l'exemple suivant.

$ echo 'un deux trois 123' | sed 's/[a-z][a-z]*/(&)/g'

Cette commande ajoutera des parenthèses autour de tous les mots en minuscules dans notre entrée. Si vous omettez le ‘g’ option, sed ne le fera que pour le premier mot, pas pour tous.

8. Utilisation d'expressions régulières étendues

Dans la commande ci-dessus, nous avons mis en correspondance tous les mots en minuscules en utilisant l'expression régulière [a-z][a-z]*. Il correspond à une ou plusieurs lettres minuscules. Une autre façon de les faire correspondre serait d'utiliser le métacaractère ‘+’ . Ceci est un exemple d'expressions régulières étendues. Ainsi, sed ne les prendra pas en charge par défaut.

$ echo 'un deux trois 123' | sed 's/[a-z]+/(&)/g'

Cette commande ne fonctionne pas comme prévu car sed ne prend pas en charge le ‘+’ métacaractère prêt à l'emploi. Vous devez utiliser les options -E ou -r pour activer les expressions régulières étendues dans sed.

$ echo 'un deux trois 123' | sed -E 's/[a-z]+/(&)/g'$ echo 'un deux trois 123' | sed -r 's/[a-z]+/(&)/g'

9. Effectuer plusieurs substitutions

Nous pouvons utiliser plus d'une commande sed en une seule fois en les séparant par ';' (point-virgule). Ceci est très utile car cela permet à l'utilisateur de créer des combinaisons de commandes plus robustes et de réduire les tracas supplémentaires à la volée. La commande suivante nous montre comment substituer trois chaînes en une seule fois en utilisant cette méthode.

$ echo 'un deux trois' | sed 's/one/1/; s/deux/2/ ; s/trois/3/'

Nous avons utilisé cet exemple simple pour illustrer comment effectuer plusieurs substitutions ou toute autre opération sed d'ailleurs.

10. Remplacer la casse sans tenir compte de la casse

L'utilitaire sed nous permet de remplacer les chaînes de manière insensible à la casse. Voyons d'abord comment sed effectue l'opération de remplacement simple suivante.

$ echo 'un UN UN' | sed 's/one/1/g' # remplace un seul

La commande de substitution ne peut correspondre qu'à une seule instance de "un" et donc la remplacer. Cependant, disons que nous voulons qu'il corresponde à toutes les occurrences de « un », quel que soit leur cas. Nous pouvons résoudre ce problème en utilisant le drapeau "i" de l'opération de substitution sed.

$ echo 'un UN UN' | sed 's/one/1/gi' # remplace tous les uns

11. Impression de lignes spécifiques

Nous pouvons afficher une ligne spécifique à partir de l'entrée en utilisant le 'p' commande. Ajoutons un peu plus de texte à notre fichier d'entrée et démontrons cet exemple.

$ echo 'Ajout de plus de texte au fichier d'entrée pour une meilleure démonstration'>> fichier-entrée

Maintenant, exécutez la commande suivante pour voir comment imprimer une ligne spécifique en utilisant 'p'.

$ sed '3p; 6p' fichier d'entrée

La sortie doit contenir les lignes numéro trois et six deux fois. Ce n'est pas ce à quoi nous nous attendions, n'est-ce pas ? Cela se produit car, par défaut, sed affiche toutes les lignes du flux d'entrée, ainsi que les lignes spécifiquement demandées. Pour imprimer uniquement les lignes spécifiques, nous devons supprimer toutes les autres sorties.

$ sed -n '3p; 6p' fichier-entrée$ sed --quiet '3p; 6p' fichier-entrée$ sed --silent '3p; 6p' fichier d'entrée

Toutes ces commandes sed sont équivalentes et n'impriment que les troisième et sixième lignes de notre fichier d'entrée. Ainsi, vous pouvez supprimer la sortie indésirable en utilisant l'un des -n , –silencieux , ou –silencieux options.

12. Impression de la plage de lignes

La commande ci-dessous imprimera une plage de lignes à partir de notre fichier d'entrée. Le symbole ‘,’ peut être utilisé pour spécifier une plage d'entrée pour sed.

$ sed -n '2,4p' fichier-entrée$ sed --quiet '2,4p' fichier-entrée$ sed --silent '2,4p' fichier-entrée

ces trois commandes sont également équivalentes. Ils imprimeront les lignes deux à quatre de notre fichier d'entrée.

13. Impression de lignes non consécutives

Supposons que vous souhaitiez imprimer des lignes spécifiques à partir de votre saisie de texte à l'aide d'une seule commande. Vous pouvez gérer ces opérations de deux manières. La première consiste à joindre plusieurs opérations d'impression en utilisant le ';' séparateur.

$ sed -n '1,2p; 5,6p' fichier d'entrée

Cette commande imprime les deux premières lignes du fichier d'entrée suivies des deux dernières lignes. Vous pouvez également le faire en utilisant le -e option de sed. Notez les différences dans la syntaxe.

$ sed -n -e '1,2p' -e '5,6p' fichier d'entrée

14. Impression toutes les n-ièmes lignes

Disons que nous voulions afficher chaque seconde ligne de notre fichier d'entrée. L'utilitaire sed rend cela très facile en fournissant le tilde ‘~’ opérateur. Jetez un coup d'œil à la commande suivante pour voir comment cela fonctionne.

$ sed -n '1~2p' fichier d'entrée

Cette commande fonctionne en imprimant la première ligne suivie de chaque deuxième ligne de l'entrée. La commande suivante imprime la deuxième ligne suivie d'une ligne sur trois à partir de la sortie d'une simple commande ip.

$ ip -4 a | sed -n '2~3p'

15. Remplacement de texte dans une plage

Nous pouvons également remplacer du texte uniquement dans une plage spécifiée de la même manière que nous l'avons imprimé. La commande ci-dessous montre comment remplacer les "1" par des 1 dans les trois premières lignes de notre fichier d'entrée à l'aide de sed.

fichier d'entrée $ sed '1,3 s/one/1/gi'

Cette commande laissera toutes les autres non affectées. Ajoutez quelques lignes contenant un à ce fichier et essayez de le vérifier par vous-même.

16. Suppression de lignes de l'entrée

La commande ed ‘d’ nous permet de supprimer des lignes spécifiques ou une plage de lignes du flux de texte ou des fichiers d'entrée. La commande suivante montre comment supprimer la première ligne de la sortie de sed.

fichier d'entrée $ sed '1d'

Étant donné que sed n'écrit que sur la sortie standard, cette suppression ne se répercutera pas sur le fichier d'origine. La même commande peut être utilisée pour supprimer la première ligne d'un flux de texte multiligne.

$ ps | sed '1d'

Donc, en utilisant simplement le 'd' commande après l'adresse de la ligne, nous pouvons supprimer l'entrée pour sed.

17. Suppression d'une plage de lignes de l'entrée

Il est également très facile de supprimer une plage de lignes en utilisant l'opérateur "," à côté du "d" option. La prochaine commande sed supprimera les trois premières lignes de notre fichier d'entrée.

fichier d'entrée $ sed '1,3d'

Nous pouvons également supprimer des lignes non consécutives en utilisant l'une des commandes suivantes.

$ sed '1d; 3d ; 5d' fichier d'entrée

Cette commande affiche la deuxième, la quatrième et la dernière ligne de notre fichier d'entrée. La commande suivante omet certaines lignes arbitraires de la sortie d'une simple commande Linux ip.

$ ip -4 a | sed '1d ; 3d ; 4d ; 6j'

18. Suppression de la dernière ligne

L'utilitaire sed a un mécanisme simple qui nous permet de supprimer la dernière ligne d'un flux de texte ou d'un fichier d'entrée. C'est le '$' symbole et peut également être utilisé pour d'autres types d'opérations en plus de la suppression. La commande suivante supprime la dernière ligne du fichier d'entrée.

fichier d'entrée $ sed '$d'

Ceci est très utile car nous pouvons souvent connaître le nombre de lignes à l'avance. Cela fonctionne de manière similaire pour les entrées de pipeline.

$ séq 3 | sed '$d'

19. Supprimer toutes les lignes sauf certaines spécifiques

Un autre exemple pratique de suppression de sed consiste à supprimer toutes les lignes sauf celles qui sont spécifiées dans la commande. Ceci est utile pour filtrer les informations essentielles des flux de texte ou de la sortie d'autres commandes de terminal Linux.

$ gratuit | sed '2!d'

Cette commande affichera uniquement l'utilisation de la mémoire, qui se trouve sur la deuxième ligne. Vous pouvez également faire la même chose avec les fichiers d'entrée, comme illustré ci-dessous.

fichier d'entrée $ sed '1,3!d'

Cette commande supprime toutes les lignes sauf les trois premières du fichier d'entrée.

20. Ajout de lignes vides

Parfois, le flux d'entrée peut être trop concentré. Vous pouvez utiliser l'utilitaire sed pour ajouter des lignes vides entre les entrées dans de tels cas. L'exemple suivant ajoute une ligne vide entre chaque ligne de la sortie de la commande ps.

$ ps aux | sed 'G'

Le 'G' La commande ajoute cette ligne vide. Vous pouvez ajouter plusieurs lignes vides en utilisant plus d'un  'G' commande pour sed.

$ sed 'G ; Fichier d'entrée G'

La commande suivante vous montre comment ajouter une ligne vide après un numéro de ligne spécifique. Il ajoutera une ligne vide après la troisième ligne de notre fichier d'entrée.

fichier d'entrée $ sed '3G'

21. Remplacer du texte sur des lignes spécifiques

L'utilitaire sed permet aux utilisateurs de substituer du texte sur une ligne particulière. Ceci est utile dans un certain nombre de scénarios différents. Disons que nous voulons remplacer le mot "un" sur la troisième ligne de notre fichier d'entrée. Nous pouvons utiliser la commande suivante pour ce faire.

$ sed '3 s/one/1/' fichier d'entrée

Le ‘3’ avant le début du ‘s’ commande précise que l'on souhaite uniquement remplacer le mot qui se trouve sur la troisième ligne.

22. Substitution du N-ième mot d'une chaîne

Nous pouvons également utiliser la commande sed pour remplacer la n-ième occurrence d'un motif pour une chaîne donnée. L'exemple suivant illustre cela à l'aide d'un seul exemple d'une ligne dans bash.

$ echo 'un un un un un un' | sed 's/one/1/3'

Cette commande remplacera le troisième "un" par le chiffre 1. Cela fonctionne de la même manière pour les fichiers d'entrée. La commande ci-dessous remplace les derniers "deux" de la deuxième ligne du fichier d'entrée.

$ cat fichier_d'entrée | sed '2 s/deux/2/2'

Nous sélectionnons d'abord la deuxième ligne, puis nous spécifions l'occurrence du motif à modifier.

23. Ajout de nouvelles lignes

Vous pouvez facilement ajouter de nouvelles lignes au flux d'entrée en utilisant la commande 'a' . Consultez l'exemple simple ci-dessous pour voir comment cela fonctionne.

$ sed 'une nouvelle ligne dans l'entrée' fichier d'entrée

La commande ci-dessus ajoutera la chaîne "nouvelle ligne dans l'entrée" après chaque ligne du fichier d'entrée d'origine. Cependant, ce n'est peut-être pas ce que vous vouliez. Vous pouvez ajouter de nouvelles lignes après une ligne spécifique en utilisant la syntaxe suivante.

$ sed '3 une nouvelle ligne dans l'entrée' fichier-entrée

24. Insertion de nouvelles lignes

Nous pouvons également insérer des lignes au lieu de les ajouter. La commande ci-dessous insère une nouvelle ligne avant chaque ligne d'entrée.

$ séq 5 | sed 'i 888'

Le "je" La commande provoque l'insertion de la chaîne 888 avant chaque ligne de la sortie de seq. Pour insérer une ligne avant une ligne d'entrée spécifique, utilisez la syntaxe suivante.

$ séq 5 | sed '3 i 333'

Cette commande ajoutera le nombre 333 avant la ligne qui en contient en fait trois. Ce sont des exemples simples d'insertion de ligne. Vous pouvez facilement ajouter des chaînes en faisant correspondre les lignes à l'aide de modèles.

25. Modification des lignes d'entrée

On peut aussi changer les lignes d'un flux d'entrée directement en utilisant le ‘c’ commande de l'utilitaire sed. Ceci est utile lorsque vous savez exactement quelle ligne remplacer et que vous ne voulez pas faire correspondre la ligne à l'aide d'expressions régulières. L'exemple ci-dessous modifie la troisième ligne de la sortie de la commande seq.

$ séq 5 | sed '3 c 123'

Il remplace le contenu de la troisième ligne, qui est 3, par le nombre 123. L'exemple suivant nous montre comment changer la dernière ligne de notre fichier d'entrée en utilisant 'c' .

$ sed '$ c CHANGED STRING' fichier d'entrée

Nous pouvons également utiliser regex pour sélectionner le numéro de ligne à modifier. L'exemple suivant illustre cela.

$ sed '/demo*/ c CHANGED TEXT' fichier d'entrée

26. Création de fichiers de sauvegarde pour l'entrée

Si vous souhaitez transformer du texte et enregistrer les modifications dans le fichier d'origine, nous vous recommandons fortement de créer des fichiers de sauvegarde avant de continuer. La commande suivante effectue certaines opérations sed sur notre fichier d'entrée et l'enregistre en tant qu'original. De plus, il crée une sauvegarde appelée input-file.old par précaution.

$ sed -i.old 's/one/1/g; s/deux/2/g ; s/three/3/g' fichier_entrée

Le -i L'option écrit les modifications apportées par sed dans le fichier d'origine. La partie suffixe .old est responsable de la création du document input-file.old.

27. Impression de lignes basées sur des motifs

Disons que nous voulons imprimer toutes les lignes d'une entrée basée sur un certain modèle. C'est assez facile lorsque nous combinons les commandes sed 'p' avec le -n option. L'exemple suivant illustre cela en utilisant le fichier d'entrée.

$ sed -n '/^for/ p' fichier_entrée

Cette commande recherche le motif "pour" au début de chaque ligne et n'imprime que les lignes qui commencent par lui. Le ‘^’ Le caractère est un caractère d'expression régulière spécial appelé ancre. Il spécifie que le motif doit être situé au début de la ligne.

28. Utilisation de SED comme alternative à GREP

La commande grep de Linux recherche un modèle particulier dans un fichier et, s'il le trouve, affiche la ligne. Nous pouvons émuler ce comportement à l'aide de l'utilitaire sed. La commande suivante illustre cela à l'aide d'un exemple simple.

$ sed -n 's/fraise/&/p' /usr/share/dict/american-english

Cette commande localise le mot fraise dans l'anglais américain fichier dictionnaire. Cela fonctionne en recherchant le motif fraise, puis utilise une chaîne correspondante à côté du 'p' commande pour l'imprimer. Le -n flag supprime toutes les autres lignes de la sortie. Nous pouvons rendre cette commande plus simple en utilisant la syntaxe suivante.

$ sed -n '/fraise/p' /usr/share/dict/american-english

29. Ajout de texte à partir de fichiers

Le ‘r’ La commande de l'utilitaire sed nous permet d'ajouter le texte lu à partir d'un fichier au flux d'entrée. La commande suivante génère un flux d'entrée pour sed à l'aide de la commande seq et ajoute les textes contenus par input-file à ce flux.

$ séq 5 | sed 'r fichier_entrée'

Cette commande ajoutera le contenu du fichier d'entrée après chaque séquence d'entrée consécutive produite par seq. Utilisez la commande suivante pour ajouter le contenu après les numéros générés par seq.

$ séq 5 | sed '$ r fichier-entrée'

Vous pouvez utiliser la commande suivante pour ajouter le contenu après la n-ième ligne d'entrée.

$ séq 5 | sed '3 r fichier-entrée'

30. Écriture de modifications dans les fichiers

Supposons que nous ayons un fichier texte contenant une liste d'adresses Web. Dites, certains d'entre eux commencent par www, certains https et d'autres http. Nous pouvons changer toutes les adresses qui commencent par www pour commencer par https et enregistrer uniquement celles qui ont été modifiées dans un tout nouveau fichier.

Sites Web de $ sed 's/www/https/w modified-websites

Maintenant, si vous inspectez le contenu du fichier modified-websites, vous ne trouverez que les adresses qui ont été modifiées par sed. Le 'w nom de fichier L'option ' oblige sed à écrire les modifications dans le nom de fichier spécifié. Il est utile lorsque vous traitez des fichiers volumineux et que vous souhaitez stocker les données modifiées séparément.

31. Utilisation des fichiers de programme SED

Parfois, vous devrez peut-être effectuer un certain nombre d'opérations sed sur un ensemble d'entrées donné. Dans de tels cas, il est préférable d'écrire un fichier programme contenant tous les différents scripts sed. Vous pouvez alors simplement invoquer ce fichier de programme en utilisant le -f option de l'utilitaire sed.

$ cat <> sed-scripts/a/A/gs/e/E/gs/i/I/gs/o/O/gs/u/U/gEOF

Ce programme sed change toutes les voyelles minuscules en majuscules. Vous pouvez l'exécuter en utilisant la syntaxe ci-dessous.

$ sed -f sed-script fichier-entrée$ sed --file=sed-script  
32. Utilisation des commandes SED multilignes 
 

 Si vous écrivez un grand programme sed qui s'étend sur plusieurs lignes, vous devrez les citer correctement. La syntaxe diffère légèrement entre les différents shells Linux. Heureusement, c'est très simple pour le bourne shell et ses dérivés (bash).
 
$ sed 's/a/A/g s/e/E/g s/i/I/g s/o/O/g s/u/U/g'  

 Dans certains shells, comme le shell C (csh), vous devez protéger les guillemets à l'aide du caractère barre oblique inverse (\).
 
$ sed 's/a/A/g \s/e/E/g \s/i/I/g \s/o/O/g \s/u/U/g'  
33. Impression des numéros de ligne 
 

 Si vous souhaitez imprimer le numéro de ligne contenant une chaîne spécifique, vous pouvez le rechercher à l'aide d'un motif et l'imprimer très facilement. Pour cela, vous devrez utiliser le ‘=’ commande de l'utilitaire sed.
 
$ sed -n '/ion*/ ='  

 Cette commande recherchera le motif donné dans le fichier d'entrée et imprimera son numéro de ligne dans la sortie standard. Vous pouvez également utiliser une combinaison de grep et awk pour résoudre ce problème.
 
$ cat -n fichier_d'entrée | grep 'ion*' | awk '{print $1}'
 

 Vous pouvez utiliser la commande suivante pour imprimer le nombre total de lignes dans votre entrée.
 
$ sed -n '$=' fichier_entrée
 
34. Empêcher l'écrasement des liens symboliques 
 

 Le sed ‘i’ ou ‘–sur place La commande écrase souvent tous les liens système avec des fichiers normaux. Il s'agit d'une situation indésirable dans de nombreux cas, et les utilisateurs peuvent donc vouloir empêcher que cela ne se produise. Heureusement, sed fournit une option de ligne de commande simple pour désactiver l'écrasement des liens symboliques.
 
$ echo 'apple'> fruit$ ln --symbolic fruit fruit-link$ sed --in-place --follow-symlinks 's/apple/banana/' fruit-link$ chat fruit
 

 Ainsi, vous pouvez empêcher l'écrasement des liens symboliques en utilisant le  –follow-symlinks option de l'utilitaire sed. De cette façon, vous pouvez conserver les liens symboliques lors du traitement de texte.
 
35. Impression de tous les noms d'utilisateur depuis /etc/passwd 
 

 Le /etc/passwd Le fichier contient des informations à l'échelle du système pour tous les comptes d'utilisateurs sous Linux. Nous pouvons obtenir une liste de tous les noms d'utilisateur disponibles dans ce fichier en utilisant un simple programme sed en une seule ligne. Examinez attentivement l'exemple ci-dessous pour voir comment cela fonctionne.
 
$ sed 's/\([^:]*\).*/\1/' /etc/passwd
 

 Nous avons utilisé un modèle d'expression régulière pour obtenir le premier champ de ce fichier tout en supprimant toutes les autres informations. C'est là que résident les noms d'utilisateur dans le  /etc/passwd fichier.
 
36. Suppression des lignes commentées de l'entrée 
 

 De nombreux outils système, ainsi que des applications tierces, sont fournis avec des fichiers de configuration. Ces fichiers contiennent généralement de nombreux commentaires décrivant les paramètres en détail. Cependant, vous souhaiterez parfois afficher uniquement les options de configuration tout en conservant les commentaires d'origine.
 
$ chat ~/.bashrc | sed -e 's/#.*//;/^$/d'
 

 Cette commande supprime les lignes commentées du fichier de configuration bash. Les commentaires sont marqués d'un signe « # » qui précède. Nous avons donc supprimé toutes ces lignes en utilisant un simple modèle de regex. Si les commentaires sont marqués à l'aide d'un symbole différent, remplacez le « # » dans le modèle ci-dessus par ce symbole spécifique.
 
$ chat ~/.vimrc | sed -e 's/".*//;/^$/d'
 

 Cela supprimera les commentaires du fichier de configuration vim, qui commence par un guillemet double (").
 

 
 
37. Suppression des espaces blancs de l'entrée 
 

 De nombreux documents texte sont remplis d'espaces blancs inutiles. Souvent, ils sont le résultat d'un mauvais formatage et peuvent gâcher l'ensemble des documents. Heureusement, sed permet aux utilisateurs de supprimer assez facilement ces espacements indésirables. Vous pouvez utiliser la commande suivante pour supprimer les espaces blancs de tête d'un flux d'entrée.
 
$ sed 's/^[ \t]*//' whitespace.txt
 

 Cette commande supprimera tous les espaces blancs de tête du fichier whitespace.txt. Si vous souhaitez supprimer les espaces blancs de fin, utilisez plutôt la commande suivante.
 
$ sed 's/[ \t]*$//' whitespace.txt
 

 Vous pouvez également utiliser la commande sed pour supprimer simultanément les espaces de début et de fin. La commande ci-dessous peut être utilisée pour effectuer cette tâche.
 
$ sed 's/^[ \t]*//;s/[ \t]*$//' whitespace.txt
 
38. Création de décalages de page avec SED 
 

 Si vous avez un fichier volumineux sans remplissage avant, vous pouvez créer des décalages de page pour celui-ci. Les décalages de page sont simplement des espaces blancs qui nous aident à lire les lignes d'entrée sans effort. La commande suivante crée un décalage de 5 espaces vides.
 
$ sed 's/^/ /' fichier_entrée
 

 Augmentez ou réduisez simplement l'espacement pour spécifier un décalage différent. La commande suivante réduit le décalage de page à 3 lignes vides.
 
$ sed 's/^/ /' fichier_entrée
 
39. Inverser les lignes d'entrée 
 

 La commande suivante nous montre comment utiliser sed pour inverser l'ordre des lignes dans un fichier d'entrée. Il émule le comportement du Linux tac commande.
 
$ sed '1!G;h;$!d' fichier d'entrée
 

 Cette commande inverse les lignes du document de ligne d'entrée. Cela peut également être fait en utilisant une méthode alternative.
 
$ sed -n '1!G;h;$p' fichier_entrée
 
40. Inverser les caractères d'entrée 
 

 Nous pouvons également utiliser l'utilitaire sed pour inverser les caractères sur les lignes d'entrée. Cela inversera l'ordre de chaque caractère consécutif dans le flux d'entrée.
 
$ sed '/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//' fichier-entrée 

 Cette commande émule le comportement de Linux rev commande. Vous pouvez le vérifier en exécutant la commande ci-dessous après celle ci-dessus.
 
fichier d'entrée $ rev
 
41. Joindre des paires de lignes d'entrée 
 

 La commande sed simple suivante joint deux lignes consécutives d'un fichier d'entrée en une seule ligne. C'est utile lorsque vous avez un texte volumineux contenant des lignes fractionnées.
 
$ sed '$!N;s/\n/ /' fichier-entrée$ tail -15 /usr/share/dict/american-english | sed '$!N;s/\n/ /'
 

 Il est utile dans un certain nombre de tâches de manipulation de texte.
 
42. Ajout de lignes vides sur chaque N-ième ligne d'entrée 
 

 Vous pouvez ajouter une ligne vierge sur chaque nième ligne du fichier d'entrée très facilement en utilisant sed. Les commandes suivantes ajoutent une ligne vide sur chaque troisième ligne du fichier d'entrée.
 
$ sed 'n;n;G;' fichier_entrée
 

 Utilisez ce qui suit pour ajouter la ligne vide sur chaque deuxième ligne.
 
$ sed 'n;G;' fichier_entrée
 
43. Impression des N-ièmes dernières lignes 
 

 Auparavant, nous avons utilisé les commandes sed pour imprimer les lignes d'entrée en fonction du numéro de ligne, des plages et du motif. Nous pouvons également utiliser sed pour émuler le comportement des commandes head ou tail. L'exemple suivant imprime les 3 dernières lignes du fichier d'entrée.
 
$ sed -e :a -e '$q;N;4,$D;ba' fichier-entrée
 

 Il est similaire à la commande tail ci-dessous tail -3 input-file.
 
44. Imprimer des lignes contenant un nombre spécifique de caractères 
 

 Il est très facile d'imprimer des lignes en fonction du nombre de caractères. La commande simple suivante imprimera les lignes contenant 15 caractères ou plus.
 
$ sed -n '/^.\{15\}/p' fichier_entrée
 

 Utilisez la commande ci-dessous pour imprimer des lignes de moins de 20 caractères.
 
$ sed -n '/^.\{20\}/!p' fichier_entrée
 

 Nous pouvons également le faire de manière plus simple en utilisant la méthode suivante.
 
$ sed '/^.\{20\}/d' fichier_entrée
 

 
 
45. Suppression des lignes en double 
 

 L'exemple sed suivant nous montre comment émuler le comportement de Linux uniq commande. Il supprime deux lignes consécutives en double de l'entrée.
 
$ sed '$!N; /^\(.*\)\n\1$/!P ; Fichier d'entrée D'
 

 Cependant, sed ne peut pas supprimer toutes les lignes en double si l'entrée n'est pas triée. Although you can sort the text using the sort command and then connect the output to sed using a pipe, it will change the orientation of the lines.
 
46. Deleting All Blank Lines 
 

 If your text file contains a lot of unnecessary blank lines, you may delete them using the sed utility. The below command demonstrates this.
 
$ sed '/^$/d' input-file$ sed '/./!d' input-file
 

 Both of these commands will delete any blank lines present in the specified file.
 
47. Deleting Last Lines of Paragraphs 
 

 You can delete the last line of all paragraphs using the following sed command. We will use a dummy filename for this example. Replace this with the name of an actual file that contains some paragraphs.
 
$ sed -n '/^$/{p;h;};/./{x;/./p;}' paragraphs.txt
 
48. Displaying the Help Page 
 

 The help page contains summarized information on all available options and usage of the sed program. You can invoke this by using the following syntax.
 
$ sed -h$ sed --help
 

 You can use any of these two commands to find a nice, compact overview of the sed utility.
 
49. Displaying the Manual Page 
 

 The manual page provides an in-depth discussion of sed, its usage, and all available options. You should read this carefully to understand sed clearly.
 
$ man sed
 
50. Displaying Version Information 
 

 The –version option of sed allows us to view which version of sed is installed in our machine. It is useful when debugging errors and reporting bugs.
 
$ sed --version
 

 The above command will display the version information of the sed utility in your system.
 
Fin des pensées 
 

 The sed command is one of the most widely used text manipulation tools provided by Linux distributions. It is one of the three primary filtering utilities in Unix, alongside grep and awk. We have outlined 50 simple yet useful examples to help readers get started with this amazing tool. We highly recommend users to try these commands themselves to gain practical insights. Additionally, try tweaking the examples given in this guide and examine their effect. It will help you master sed quickly. Hopefully, you’ve learned the basics of sed clearly. Don’t forget to comment below if you’ve any questions.