Technique

La commande sed sous Linux : le guide complet avec exemples

4 juillet 2026 · par Romain RICHER

sed (pour stream editor, éditeur de flux) est l’un des outils les plus utiles du terminal Unix/Linux. Il permet de transformer du texte automatiquement : remplacer des mots, supprimer des lignes, insérer du contenu, le tout sans ouvrir un seul fichier dans un éditeur. C’est l’outil de référence pour modifier des fichiers en masse ou à la volée dans un script.

Sa réputation de commande « cryptique » vient surtout d’une syntaxe compacte. Ce guide la démystifie pas à pas : la substitution de base, les drapeaux qui en changent le comportement, le ciblage de lignes précises, la suppression, l’insertion, la modification directe des fichiers, puis les pièges classiques et les combinaisons avec find et grep. Tous les exemples sont neutres et réutilisables tels quels.

Le principe de sed

sed lit un texte ligne par ligne, applique une transformation à chacune, et renvoie le résultat. Par défaut, il n’écrit rien dans le fichier d’origine : il affiche simplement le résultat à l’écran. C’est un point rassurant pour débuter — vous pouvez expérimenter sans rien casser.

La syntaxe générale est :

sed 'commande' fichier

On peut aussi lui passer du texte via un tube (pipe), ce qui est très courant :

cat fichier | sed 'commande'

La substitution : le cœur de sed

L’usage principal de sed, de très loin, est le remplacement de texte. Il s’écrit avec la commande s (pour substitute), selon le format s/motif/remplacement/.

Pour remplacer la première occurrence de « bonjour » par « salut » sur chaque ligne :

sed 's/bonjour/salut/' fichier.txt

Le résultat s’affiche à l’écran, le fichier reste inchangé. C’est la brique de base à partir de laquelle tout le reste se construit.

Remplacer toutes les occurrences avec le drapeau g

Par défaut, sed ne remplace que la première occurrence de chaque ligne. Pour remplacer toutes les occurrences, on ajoute le drapeau g (pour global) à la fin :

sed 's/bonjour/salut/g' fichier.txt

C’est probablement le drapeau que vous utiliserez le plus souvent.

Ignorer la casse avec le drapeau i

Pour que le remplacement ne tienne pas compte des majuscules et minuscules (remplacer « Bonjour », « BONJOUR » et « bonjour »), ajoutez le drapeau i :

sed 's/bonjour/salut/gi' fichier.txt

Les drapeaux se combinent : ici g et i agissent ensemble.

Remplacer une occurrence précise

On peut cibler une occurrence particulière par son numéro. Pour ne remplacer que la deuxième occurrence de chaque ligne :

sed 's/mot/nouveau/2' fichier.txt

Et pour remplacer à partir de la deuxième occurrence (la deuxième et toutes les suivantes), on combine le numéro et g :

sed 's/mot/nouveau/2g' fichier.txt

Choisir un autre séparateur

Le séparateur du s n’est pas obligatoirement le slash /. C’est très pratique quand le texte contient lui-même des slashes, typiquement des chemins de fichiers. Plutôt que d’échapper chaque slash, on utilise un autre caractère comme séparateur — souvent # ou | :

sed 's#/ancien/chemin#/nouveau/chemin#g' fichier.txt

Le résultat est bien plus lisible qu’avec des slashes échappés partout.

Cibler des lignes précises

Par défaut, sed applique sa commande à toutes les lignes. On peut restreindre l’action à certaines lignes en préfixant la commande par une adresse.

Pour n’agir que sur la ligne 3 :

sed '3 s/mot/nouveau/' fichier.txt

Pour agir sur une plage de lignes, de la 2 à la 5 :

sed '2,5 s/mot/nouveau/g' fichier.txt

Pour agir de la ligne 3 jusqu’à la fin du fichier, on utilise $ qui représente la dernière ligne :

sed '3,$ s/mot/nouveau/g' fichier.txt

Cibler les lignes contenant un motif

Plus puissant : on peut n’agir que sur les lignes qui contiennent un certain motif, en le plaçant entre slashes avant la commande. Par exemple, ne remplacer « erreur » par « alerte » que sur les lignes contenant « critique » :

sed '/critique/ s/erreur/alerte/g' fichier.txt

Supprimer des lignes

La commande d (pour delete) supprime des lignes. Comme pour la substitution, elle s’appuie sur des adresses.

Supprimer la ligne 4 :

sed '4d' fichier.txt

Supprimer une plage de lignes, de la 2 à la 6 :

sed '2,6d' fichier.txt

Supprimer toutes les lignes contenant un motif donné (par exemple les lignes de commentaire commençant par #) :

sed '/^#/d' fichier.txt

Supprimer les lignes vides est un besoin très fréquent :

sed '/^$/d' fichier.txt

Ici, ^$ désigne une ligne qui commence (^) et finit ($) immédiatement, donc une ligne vide.

Afficher seulement certaines lignes

Avec l’option -n, sed cesse d’afficher automatiquement chaque ligne. Combinée à la commande p (pour print), elle permet de n’afficher que ce qu’on veut. Pour afficher uniquement les lignes 10 à 20 :

sed -n '10,20p' fichier.txt

C’est une alternative pratique à d’autres outils pour extraire une portion précise d’un fichier.

Insérer et ajouter du texte

sed peut aussi ajouter des lignes. La commande i insère avant une ligne, a ajoute après.

Insérer une ligne avant la ligne 1 (par exemple un en-tête) :

sed '1i Voici une nouvelle première ligne' fichier.txt

Ajouter une ligne après chaque ligne contenant « section » :

sed '/section/a --- séparateur ---' fichier.txt

Modifier directement un fichier avec -i

Jusqu’ici, sed affichait le résultat sans toucher au fichier. L’option -i (pour in-place) applique les modifications directement dans le fichier. C’est puissant, mais irréversible : il n’y a pas d’annulation.

sed -i 's/ancien/nouveau/g' fichier.txt

Par prudence, sed peut créer une sauvegarde automatique avant de modifier, en indiquant un suffixe après -i. Ici, une copie .bak de l’original est conservée :

sed -i.bak 's/ancien/nouveau/g' fichier.txt

C’est une habitude à prendre pour toute modification importante : la sauvegarde ne coûte rien et peut sauver la mise.

Enchaîner plusieurs commandes

On peut appliquer plusieurs transformations en une seule fois, en les séparant par l’option -e. Par exemple, faire deux remplacements d’affilée :

sed -e 's/rouge/bleu/g' -e 's/grand/petit/g' fichier.txt

Cette approche est très utile pour normaliser un fichier en une passe (corriger plusieurs termes, uniformiser un format).

Quand les remplacements suivent un même schéma, une expression régulière avec référence arrière évite de tout écrire à la main. Le motif capturé entre  est réinjecté avec \1. Par exemple, pour retirer un appel de fonction trim(...) en ne gardant que son contenu :

sed "s/trim(\([a-zA-Z0-9_.]*\))/\1/g" fichier.txt

Une seule commande remplace ainsi ce qui aurait demandé une dizaine de substitutions écrites une par une.

Pièges et erreurs fréquentes

Quelques écueils classiques qui font perdre du temps avec sed :

Oublier le drapeau g. Sans g, seule la première occurrence de chaque ligne est remplacée. Si un remplacement « ne marche qu’à moitié », c’est souvent la cause.

Lancer un -i sans sauvegarde. L’option -i modifie le fichier sans retour possible. Prenez l’habitude de tester la commande sans -i d’abord (le résultat s’affiche à l’écran), puis d’ajouter -i.bak pour garder une copie de sécurité.

Se battre avec les slashes. Quand le motif contient des slashes (des chemins), n’échappez pas chaque slash : changez simplement de séparateur (s#…#…# ou s|…|…|). C’est plus lisible et moins source d’erreur.

Confondre le comportement de base et -n. Par défaut sed affiche toutes les lignes ; avec -n il n’affiche plus rien sauf ce que vous demandez explicitement avec p. Mélanger les deux logiques donne des résultats déroutants.

Oublier les guillemets. Entourez toujours la commande sed de guillemets simples pour éviter que le shell n’interprète les caractères spéciaux. Les guillemets doubles ne sont nécessaires que si vous devez insérer une variable.

Combiner sed avec find et grep

sed prend toute sa dimension lorsqu’on le chaîne avec d’autres outils.

find + sed : modifier plusieurs fichiers d’un coup

En couplant find (qui sélectionne les fichiers) et sed -i (qui les modifie), on effectue un remplacement sur toute une arborescence. Par exemple, remplacer un terme dans tous les fichiers .conf :

find . -type f -name "*.conf" -exec sed -i 's/ancien/nouveau/g' {} +

Le + final regroupe les fichiers pour limiter le nombre d’appels et accélérer le traitement. Là encore, une sauvegarde préalable de l’arborescence est vivement conseillée avant une modification en masse.

grep + sed : filtrer puis transformer

On peut d’abord filtrer les lignes avec grep, puis les transformer avec sed. Par exemple, extraire les lignes contenant « total » d’un fichier, puis en isoler une valeur :

grep "total" fichier.txt | sed 's/.*total *: *//'

Ici, sed supprime tout ce qui précède la valeur recherchée, ne laissant que l’information utile. Ce type d’enchaînement est au cœur du traitement de texte dans les scripts.

En résumé

sed repose sur quelques mécanismes qu’il suffit de bien assimiler :

la substitution s/motif/remplacement/, avec les drapeaux g (toutes les occurrences), i (ignorer la casse) et le numéro d’occurrence ;
le ciblage par numéro de ligne, par plage, ou par motif ;
la suppression (d) et l’affichage sélectif (-n avec p) ;
l’insertion (i) et l’ajout (a) de lignes ;
la modification en place (-i), à manier avec une sauvegarde ;
l’enchaînement de commandes (-e) et les combinaisons avec find et grep.

Le bon réflexe, comme souvent en ligne de commande : testez d’abord sans -i pour visualiser le résultat, puis appliquez la modification une fois que vous êtes sûr. Avec un peu de pratique, sed devient un outil qu’on utilise sans même y penser, aussi bien en ligne de commande que dans les scripts.

Vous avez une commande sed qui vous fait gagner un temps fou ? Cet éditeur de flux regorge de possibilités — les plus belles astuces sont souvent les plus simples.