Débuter avec sed : rechercher et remplacer en CLI

sed est un outil classique de la ligne de commande Linux pour transformer du texte rapidement. Son nom vient de stream editor : il lit des données ligne par ligne, applique des instructions, puis affiche ou écrit le résultat.

Pour débuter, sed est particulièrement utile dans trois cas : rechercher un motif, remplacer une partie du texte et modifier un fichier sans ouvrir d’éditeur interactif. On le rencontre souvent dans les scripts shell, l’administration système, le traitement de journaux et la préparation de fichiers de configuration.

Ce tutoriel explique les bases de façon progressive. Vous allez voir comment tester une commande sur la sortie standard, cibler certaines lignes, remplacer la première occurrence ou toutes les occurrences, enregistrer les changements directement dans un fichier et éviter les erreurs fréquentes liées aux guillemets, aux délimiteurs et aux expressions régulières.

Prérequis

• Un système Linux avec un shell comme bash.
• Un terminal.
• Les commandes de base : cat, echo, printf, cp, grep et less sont utiles mais non obligatoires.
• Une version de sed installée, ce qui est généralement le cas sur Linux.

Matériel nécessaire

• Un terminal Linux
• La commande sed
• Un fichier texte de test

Étapes

1. 1

   Comprendre le rôle de sed

   Avant d’écrire des commandes, il faut comprendre le comportement général de sed. Dans son usage le plus courant, l’outil lit une entrée texte, traite chaque ligne selon les commandes fournies, puis affiche le résultat sur la sortie standard.

   Autrement dit, si vous lancez une commande de remplacement simple, le fichier d’origine n’est pas modifié tant que vous n’utilisez pas une option d’édition en place. Ce point est important pour débuter sereinement : on peut tester sans risque.

   La forme la plus simple ressemble à ceci :

   bash

   sed 'commande' fichier.txt

   Exemple minimal :

   bash

   printf 'bonjour\n' | sed 's/bonjour/salut/'

   Résultat attendu :

   bash

   salut

   Ici, s signifie substitute, donc remplacer. La structure générale de cette commande est :

   bash

   s/motif/remplacement/

   Le premier élément est le texte recherché, le second est le texte de remplacement. Par défaut, sed remplace la première occurrence trouvée sur chaque ligne.

2. 2

   Créer un fichier de test pour s’exercer

   

   Pour manipuler sed sans risque, créez un petit fichier de démonstration. Utilisez par exemple cat avec une redirection :

   bash

   cat > exemple.txt <<'EOF'
   serveur=web01
   port=8080
   mode=debug
   serveur=web02
   URL=/api/v1
   [email protected]
   EOF

   Affichez ensuite son contenu :

   bash

   cat exemple.txt

   Vous obtenez un fichier simple avec plusieurs cas utiles : des clés, des valeurs, des chiffres, des caractères spéciaux comme / et une adresse e-mail.

   Pendant tout le tutoriel, gardez en tête une bonne pratique : si vous comptez modifier un vrai fichier, commencez toujours par une copie :

   bash

   cp exemple.txt exemple.sauvegarde.txt

   Ainsi, vous pouvez comparer avant et après ou revenir facilement à l’état initial.

3. 3

   Afficher un fichier avec sed

   Même si cat suffit pour lire un fichier, il est utile de voir que sed peut aussi afficher l’entrée telle quelle :

   bash

   sed '' exemple.txt

   Sur certains environnements, on préfère directement une commande explicite :

   bash

   sed -n 'p' exemple.txt

   L’option -n demande à sed de ne pas afficher automatiquement les lignes. La commande p signifie print, donc afficher.

   Cette combinaison est pratique quand vous voulez n’afficher que certaines lignes. Par exemple, pour afficher uniquement la ligne 2 :

   bash

   sed -n '2p' exemple.txt

   Pour afficher les lignes 2 à 4 :

   bash

   sed -n '2,4p' exemple.txt

   Cette logique d’adressage revient souvent avec sed : on peut appliquer une commande à une ligne précise, à une plage de lignes ou aux lignes qui correspondent à un motif.

4. 4

   Rechercher visuellement avec un motif

   sed n’est pas un moteur de recherche dédié comme grep, mais il sait très bien cibler les lignes correspondant à un motif. Pour afficher seulement les lignes contenant serveur :

   bash

   sed -n '/serveur/p' exemple.txt

   Pour afficher les lignes contenant web :

   bash

   sed -n '/web/p' exemple.txt

   La syntaxe /motif/ sert d’adresse : elle désigne les lignes qui correspondent au motif. Ensuite, la commande p les affiche.

   Vous pouvez aussi combiner adresse et remplacement. Par exemple, remplacer debug par production seulement sur les lignes contenant mode :

   bash

   sed '/mode/s/debug/production/' exemple.txt

   Cette idée est centrale : une adresse limite l’action, puis la commande s’applique uniquement aux lignes sélectionnées.

5. 5

   Remplacer du texte simplement avec s

   

   La commande la plus utilisée dans sed est s. C’est elle qui permet de remplacer du texte.

   Exemple simple :

   bash

   sed 's/web01/app01/' exemple.txt

   Le fichier d’origine ne change pas. Le résultat modifié est seulement affiché dans le terminal.

   Par défaut, sed remplace la première occurrence trouvée sur chaque ligne. Cette précision devient importante si une même ligne contient plusieurs fois le même motif.

   Regardez cet exemple avec une entrée temporaire :

   bash

   printf 'test test test\n' | sed 's/test/demo/'

   Résultat :

   bash

   demo test test

   Seule la première occurrence de la ligne a été remplacée. Pour toutes les remplacer, il faut ajouter l’indicateur global g :

   bash

   printf 'test test test\n' | sed 's/test/demo/g'

   Résultat :

   bash

   demo demo demo

   Retenez donc cette différence :

   • s/motif/remplacement/ : première occurrence par ligne
   • s/motif/remplacement/g : toutes les occurrences par ligne
6. 6

   Cibler une ligne précise ou une plage de lignes

   Une force de sed est de pouvoir remplacer du texte seulement à certains endroits du fichier.

   Pour remplacer sur une ligne précise, placez le numéro de ligne avant la commande :

   bash

   sed '2s/8080/9090/' exemple.txt

   Ici, seule la ligne 2 est concernée.

   Pour travailler sur une plage de lignes :

   bash

   sed '1,3s/web/service/' exemple.txt

   Cette commande tente le remplacement seulement entre les lignes 1 et 3.

   Vous pouvez aussi cibler par motif de début et motif de fin. Par exemple :

   bash

   sed '/^serveur=/,/^mode=/s/web/node/' exemple.txt

   Cette écriture applique le remplacement entre la première ligne qui correspond à ^serveur= et la ligne qui correspond à ^mode=.

   Les caractères ^ et $ sont utiles : ^ représente le début de ligne, $ la fin de ligne. Par exemple, pour remplacer uniquement une ligne dont la valeur entière est mode=debug :

   bash

   sed 's/^mode=debug$/mode=production/' exemple.txt

   Cette précision évite des remplacements involontaires dans des lignes plus longues.

7. 7

   Utiliser des délimiteurs adaptés

   Dans beaucoup d’exemples, le séparateur de la commande s est la barre oblique /. Pourtant, ce n’est pas une obligation. Quand le motif ou le remplacement contient déjà des /, choisir un autre délimiteur rend la commande plus lisible.

   Supposons que vous vouliez remplacer /api/v1 par /api/v2. Vous pouvez écrire :

   bash

   sed 's#/api/v1#/api/v2#' exemple.txt

   Le caractère # joue ici le rôle de séparateur. Le principe est identique.

   Autre exemple avec une URL plus longue :

   bash

   printf 'url=/var/www/site\n' | sed 's#/var/www#/srv/www#'

   Cette technique réduit fortement le besoin d’échapper les barres obliques. Quand vous débutez, c’est souvent la manière la plus confortable d’écrire des remplacements impliquant des chemins ou des URL.

8. 8

   Découvrir les expressions régulières les plus utiles pour débuter

   

   sed sait travailler avec des motifs plus souples que du texte strictement littéral. Sans entrer dans tous les détails, quelques bases suffisent pour commencer efficacement.

   • . : n’importe quel caractère simple
   • * : répétition de l’élément précédent, zéro fois ou plus
   • ^ : début de ligne
   • $ : fin de ligne
   • [0-9] : un chiffre
   • [a-z] : une lettre minuscule parmi l’intervalle indiqué

   Exemple pour remplacer le port, quel que soit son nombre exact, si la ligne suit le format port=nombre :

   bash

   sed 's/^port=[0-9][0-9]*/port=9090/' exemple.txt

   Ici, [0-9] désigne un chiffre, et [0-9]* permet d’en avoir plusieurs.

   Autre exemple : afficher uniquement les lignes qui commencent par une lettre minuscule :

   bash

   sed -n '/^[a-z]/p' exemple.txt

   Si vous voulez travailler sur des motifs littéraux contenant des caractères spéciaux, il faut parfois les échapper avec une barre oblique inverse \. Par exemple, un point . représente normalement un caractère quelconque. Pour chercher un vrai point, on l’écrit souvent ainsi :

   bash

   sed -n '/example\.com/p' exemple.txt

   Ce type de détail compte surtout quand vous manipulez des noms de domaine, des extensions de fichiers ou des chaînes contenant des caractères interprétés par les expressions régulières.

9. 9

   Réutiliser une partie du texte trouvé

   Au-delà du remplacement simple, sed peut réutiliser une partie de ce qu’il a trouvé. Pour débuter, cela permet déjà de restructurer des lignes.

   Prenons une ligne au format clé=valeur. On peut inverser l’ordre de façon simple :

   bash

   printf 'mode=debug\n' | sed 's/^\([a-z]*\)=\(.*\)$/\2 (\1)/'

   Résultat :

   bash

   debug (mode)

   Dans cet exemple :

   • \( ... \) capture une partie du motif
   • \1 réutilise la première partie capturée
   • \2 réutilise la deuxième

   Vous n’avez pas besoin de maîtriser toutes les expressions régulières pour utiliser cette idée. Retenez simplement qu’on peut entourer des morceaux pour les récupérer dans le remplacement.

   Autre exemple utile, reformater une ligne serveur=web01 :

   bash

   sed 's/^serveur=\(.*\)$/hote: \1/' exemple.txt

   Cette commande transforme seulement les lignes qui commencent par serveur=.

10. 10

    Modifier un fichier en place avec prudence

    Jusqu’ici, les commandes affichent un résultat sans changer le fichier source. Pour écrire les modifications directement dans le fichier, on utilise l’option -i.

    bash

    sed -i 's/debug/production/' exemple.txt

    Après cette commande, le contenu de exemple.txt est modifié sur le disque. Vérifiez-le :

    bash

    cat exemple.txt

    Cette opération est pratique, mais elle mérite une habitude de sécurité : créer une sauvegarde avant ou pendant la modification. Une méthode simple consiste à copier le fichier avant :

    bash

    cp exemple.txt exemple.txt.bak

    Ensuite, appliquez la commande :

    bash

    sed -i 's/production/debug/' exemple.txt

    Quand vous débutez, préférez ce déroulé :

    1. Tester sans -i
    2. Vérifier la sortie
    3. Créer une sauvegarde
    4. Relancer avec -i

    Cette méthode limite les erreurs sur les fichiers de configuration ou les scripts.

11. 11

    Enregistrer le résultat dans un autre fichier

    Si vous ne voulez pas modifier le fichier original, vous pouvez rediriger la sortie vers un nouveau fichier :

    bash

    sed 's/web/node/g' exemple.txt > exemple.modifie.txt

    Ensuite, comparez si besoin :

    bash

    cat exemple.modifie.txt

    Cette approche est très utile dans les scripts ou quand vous voulez générer une nouvelle version d’un fichier à partir d’un modèle. Elle garde toujours une séparation claire entre l’entrée et la sortie.

    Vous pouvez aussi utiliser un fichier temporaire, vérifier le résultat, puis remplacer l’ancien fichier vous-même si tout est correct. Même si cela demande une commande supplémentaire, cette pratique reste très rassurante quand les données sont importantes.

12. 12

    Supprimer ou afficher certaines lignes

    sed ne sert pas seulement à remplacer. Il peut aussi supprimer des lignes ou n’en afficher qu’une partie.

    Pour supprimer une ligne précise de l’affichage :

    bash

    sed '3d' exemple.txt

    La commande d signifie delete. Le fichier n’est pas modifié tant que vous n’utilisez pas l’édition en place ou une redirection vers un autre fichier.

    Pour supprimer les lignes vides d’une entrée :

    bash

    sed '/^$/d' fichier.txt

    Pour supprimer les lignes contenant un motif :

    bash

    sed '/debug/d' exemple.txt

    Inversement, avec -n et p, vous pouvez filtrer et n’afficher que ce qui vous intéresse :

    bash

    sed -n '/^serveur=/p' exemple.txt

    Ce n’est pas l’usage principal demandé par le sujet, mais ces commandes complètent naturellement l’apprentissage de la recherche et de la modification en ligne de commande.

13. 13

    Ajouter un indicateur de confirmation visuelle

    Quand vous testez un remplacement, il peut être utile de n’afficher que les lignes effectivement modifiées. Une manière simple est d’associer l’option -n, la commande de substitution et l’indicateur p à la fin de la substitution :

    bash

    sed -n 's/web/node/p' exemple.txt

    Ici, seules les lignes où le remplacement a réussi sont affichées.

    C’est très pratique pour valider un motif avant d’utiliser -i. Vous voyez immédiatement quelles lignes seront touchées, sans être noyé dans le reste du fichier.

    Vous pouvez aussi utiliser cette idée sur une ligne ciblée :

    bash

    sed -n '/^serveur=/s/web/node/p' exemple.txt

    Dans un flux de travail prudent, cette technique fait partie des meilleurs réflexes pour éviter une modification trop large.

14. 14

    Chaîner plusieurs opérations simples

    Il est possible d’enchaîner plusieurs commandes sed dans un même appel. Pour débuter, la forme la plus lisible consiste à utiliser plusieurs options -e.

    bash

    sed -e 's/debug/production/' -e 's/web/node/g' exemple.txt

    Cette commande effectue deux remplacements successifs sur le même flux.

    Autre exemple, supprimer une ligne puis modifier une autre :

    bash

    sed -e '/^email=/d' -e 's/^port=8080$/port=9090/' exemple.txt

    Le chaînage est utile quand une seule transformation ne suffit pas. Toutefois, pour apprendre correctement, il vaut mieux commencer par une commande à la fois, vérifier le résultat, puis combiner ensuite seulement les opérations stables et bien comprises.

15. 15

    Bien gérer les guillemets dans le shell

    Beaucoup d’erreurs avec sed ne viennent pas de sed lui-même, mais du shell. En pratique, on entoure très souvent le script sed avec des guillemets simples :

    bash

    sed 's/ancien/nouveau/' fichier.txt

    Cette habitude évite que le shell interprète certains caractères spéciaux avant sed.

    Les guillemets doubles peuvent être utiles si vous voulez insérer la valeur d’une variable shell, mais ils demandent plus d’attention. Exemple :

    bash

    ancien='debug'
    nouveau='production'
    sed "s/$ancien/$nouveau/" exemple.txt

    Quand vous débutez, gardez une règle simple :

    • Sans variable shell : préférez les guillemets simples
    • Avec variable shell : utilisez les guillemets doubles en vérifiant soigneusement le contenu

    Si une commande se comporte de façon étrange, vérifiez toujours d’abord les guillemets, les espaces et les caractères spéciaux présents dans le motif ou dans le remplacement.

16. 16

    Construire une méthode de travail sûre

    Pour terminer la partie pratique, voici une méthode simple et fiable que vous pouvez appliquer presque à chaque fois :

    1. Afficher les lignes concernées avec sed -n '/motif/p'
    2. Tester le remplacement sans -i
    3. Si besoin, n’afficher que les lignes réellement modifiées avec -n et p
    4. Créer une sauvegarde du fichier
    5. Appliquer la modification en place ou écrire le résultat dans un nouveau fichier
    6. Vérifier le contenu final avec cat, grep ou less

    Exemple complet :

    bash

    sed -n '/^mode=/p' exemple.txt
    sed -n 's/^mode=debug$/mode=production/p' exemple.txt
    cp exemple.txt exemple.txt.bak
    sed -i 's/^mode=debug$/mode=production/' exemple.txt
    cat exemple.txt

    Cette séquence est simple, répétable et adaptée à des fichiers de configuration modestes, à des scripts ou à des fichiers texte utilisés au quotidien.

Erreurs fréquentes & dépannage

• Oublier que sed n’écrit pas dans le fichier par défaut : sans -i ni redirection, le résultat est seulement affiché dans le terminal.
• Utiliser -i trop tôt : testez toujours la commande sans modification en place avant de l’appliquer au vrai fichier.
• Confondre première occurrence et toutes les occurrences : sans g, seule la première occurrence par ligne est remplacée.
• Choisir un mauvais délimiteur : si votre motif contient beaucoup de /, utilisez par exemple # pour rendre la commande plus lisible.
• Mal gérer les caractères spéciaux : un point . n’est pas un point littéral, il représente un caractère quelconque dans un motif.
• Oublier les ancres ^ et $ : sans elles, un remplacement peut toucher plus de lignes que prévu.
• Se tromper dans les guillemets : les guillemets simples sont souvent le choix le plus sûr pour écrire une commande sed.

Astuces & pour aller plus loin

• Commencez par sed -n '/motif/p' fichier pour visualiser les lignes ciblées avant toute modification.
• Utilisez sed -n 's/motif/remplacement/p' fichier pour n’afficher que les lignes réellement modifiées.
• Quand vous remplacez des chemins ou des URL, préférez un autre séparateur que /, par exemple #.
• Faites une copie du fichier avant toute édition en place : cp fichier fichier.bak.
• Écrivez d’abord une commande simple et correcte, puis ajoutez progressivement les conditions, plages de lignes ou indicateurs comme g.

Questions fréquentes

Quelle différence entre sed et grep ?

Dans ce tutoriel, sed est utilisé pour rechercher des lignes mais surtout pour transformer du texte, par exemple avec des remplacements. grep est plutôt employé pour filtrer et afficher les lignes qui correspondent à un motif.

Est-ce que sed modifie toujours le fichier ?

Non. Par défaut, sed affiche le résultat sur la sortie standard. Pour modifier un fichier sur le disque, il faut utiliser l’édition en place avec -i ou rediriger la sortie vers un autre fichier.

Pourquoi mon remplacement ne change que la première occurrence ?

Parce que la commande s/motif/remplacement/ remplace seulement la première occurrence trouvée sur chaque ligne. Ajoutez g à la fin pour remplacer toutes les occurrences de la ligne.

Comment remplacer un chemin contenant des / ?

Vous pouvez utiliser un autre délimiteur que la barre oblique. Par exemple : sed 's#/ancien/chemin#/nouveau/chemin#' fichier.txt. Cela rend la commande plus lisible.

Comment tester une commande sans risque ?

Exécutez d’abord la commande sans -i pour afficher le résultat dans le terminal. Vous pouvez aussi n’afficher que les lignes touchées avec sed -n 's/motif/remplacement/p' fichier, puis créer une sauvegarde avant la modification réelle.

Peut-on cibler seulement certaines lignes ?

Oui. Vous pouvez utiliser un numéro de ligne, une plage comme 2,4, ou un motif comme /serveur/ pour limiter l’action de sed.

Conclusion

sed est un excellent point d’entrée vers le traitement de texte en ligne de commande. Avec quelques commandes seulement, vous savez déjà afficher des lignes ciblées, rechercher des motifs, remplacer du texte, limiter l’action à certaines lignes et enregistrer le résultat dans un nouveau fichier ou directement dans le fichier source.

Pour progresser sans vous perdre, gardez une approche simple : observez d’abord les lignes concernées, testez ensuite le remplacement sans -i, puis appliquez la modification finale seulement après vérification et sauvegarde. Cette discipline rend sed à la fois puissant et sûr, même pour débuter.

Une fois ces bases acquises, vous pourrez aller plus loin avec des expressions régulières plus riches, des scripts sed plus longs ou l’intégration dans vos scripts shell. Mais pour un usage quotidien, les commandes vues ici couvrent déjà une grande partie des besoins les plus fréquents.