sed : remplacer et supprimer du texte

Quand on doit modifier rapidement le contenu de plusieurs fichiers, effectuer des remplacements massifs ou supprimer certaines lignes en fonction d'un motif, sed est l'outil incontournable. Conçu pour l'édition de flux, sed permet de rechercher, remplacer, supprimer ou insérer du texte directement en ligne de commande, sans ouvrir les fichiers manuellement.

Ce que vous allez apprendre

• Remplacer du texte avec la commande s/ancien/nouveau/
• Supprimer, insérer et modifier des lignes ciblées
• Utiliser des adresses (numéros de ligne, motifs) pour cibler précisément
• Éditer des fichiers en place avec -i (en sécurité)

La commande sed dans l'écosystème Linux

sed fait partie des commandes de traitement de texte sous Linux. Chaque outil a sa spécialité :

Commande	Spécialité	Quand l'utiliser
sed	Éditer du texte en flux	Remplacer, supprimer, insérer du texte
grep	Rechercher des patterns	Filtrer les lignes matchant un motif
awk	Traiter des données tabulaires	Extraire/transformer des colonnes
tr	Translitérer des caractères	Remplacer caractère par caractère
cut	Extraire des colonnes	Découper par délimiteur ou position
find	Rechercher des fichiers	Trouver des fichiers par attributs

Glissez pour voir

Combinaisons fréquentes :

# grep + sed : filtrer puis transformer
grep "ERROR" log.txt | sed 's/ERROR/ALERTE/g'

# sed + awk : modifier puis extraire
sed 's/;/,/g' data.csv | awk -F',' '{print $2}'

# find + sed : modifier plusieurs fichiers
find . -name "*.conf" -exec sed -i 's/old/new/g' {} +

Quand sed est le bon outil (et quand l'éviter)

sed excelle sur du texte non structuré, ligne par ligne. Sa limite est aussi sa définition : il ignore toute structure. Dès que la donnée est hiérarchique ou imbriquée, sed travaille à l'aveugle et produit des résultats fragiles. Le bon réflexe est de choisir l'outil qui comprend le format.

Donnée à traiter	Évitez sed, utilisez	Pourquoi
JSON	jq	jq connaît la structure ; sed casse sur l'imbrication, les espaces et l'ordre des clés
YAML	yq (mikefarah)	l'indentation et les ancres sont signifiantes, invisibles pour une substitution de chaîne
HTML / XML	xmllint, xmlstarlet, pup	HTML n'est pas un langage régulier : une regex ne sait pas suivre l'imbrication
Multi-ligne / logique	awk ou perl -0777	champs, variables et mémoire d'état que sed n'a pas

Glissez pour voir

La règle tient en une phrase : sed pour du texte plat, un outil dédié pour de la donnée structurée. Sur un serveur minimal sans jq, un sed ponctuel sur du JSON peut dépanner, mais n'en faites jamais une brique de production.

Comprendre la commande sed en 2 min

🧠 Modèle mental — Comment fonctionne sed

sed = Lire ligne → Appliquer commandes → Afficher résultat

Points clés

• sed lit le fichier ligne par ligne (flux, pas tout en mémoire)
• Chaque ligne passe par les commandes dans l'ordre
• Par défaut, sed affiche le résultat sur stdout (pas de modification du fichier)
• La commande s/ancien/nouveau/ remplace du texte
• Sans flag g, seule la première occurrence par ligne est remplacée
• Avec -i, sed modifie directement le fichier (danger !)

Règles d'or

1

Tester sans -i avant d'éditer en place Prévisualiser les changements avec sed '...' fichier avant sed -i '...' fichier

2

Utiliser un délimiteur adapté au contenu Si le texte contient des /, utiliser # ou @ comme délimiteur : s#/chemin#/autre#

Vocabulaire essentiel

s/old/new/

Substitution : remplace old par new (1ère occurrence)

s/old/new/g

Substitution globale (toutes les occurrences)

d

Delete : supprime la ligne

p

Print : affiche la ligne

-i

In-place : modifie le fichier directement

-n

No-print : n'affiche rien sauf avec p

📚 Pour aller plus loin — 12 options avancées

a\texte

Append : ajoute après la ligne

i\texte

Insert : insère avant la ligne

c\texte

Change : remplace toute la ligne

/regex/

Adresse : cible les lignes matchant regex

1,10

Plage : lignes 1 à 10

/début/,/fin/

Plage entre deux patterns

-E

Extended regex (ERE) : +, ?, |, () sans escape

&

Dans s///, représente le texte matché

\1, \2

Backreferences : groupes capturés

y/abc/xyz/

Translitération (comme tr)

q

Quit : arrête le traitement

N

Next : ajoute la ligne suivante au buffer

sed lit le fichier ligne par ligne (flux), applique les transformations demandées, puis affiche le résultat. Par défaut, le fichier original n'est pas modifié.

Syntaxe minimale

Toute invocation de sed tient dans cette forme. Retenez surtout les guillemets simples autour de la commande : ils empêchent le shell d'interpréter $, * et \ avant que sed ne les voie. Avec des guillemets doubles, sed '$d' devient une commande vide parce que bash aura d'abord remplacé $d par une variable inexistante. Le fichier est facultatif : sans lui, sed lit l'entrée standard, ce qui en fait un maillon de pipeline naturel.

sed [OPTIONS] 'COMMANDE' [FICHIER]

Les 3 parties d'une commande sed

Ce découpage sert à diagnostiquer : quand une commande sed ne fait rien, l'erreur se situe presque toujours dans une seule de ces trois parties. La colonne Obligatoire signale le point le plus souvent oublié : la sortie par défaut est stdout, donc un sed qui « ne modifie pas le fichier » se comporte normalement, il manque simplement l'option -i.

Étape	Question	Exemples	Obligatoire ?
Entrée	D'où vient le texte ?	fichier.txt, stdin (pipe)	Un des deux
Commande	Quelle transformation ?	s/old/new/g, d, p	✓ Oui
Sortie	Où va le résultat ?	stdout (défaut) ou fichier (-i)	✗ Non (défaut : stdout)

Glissez pour voir

La commande de substitution s///

La commande la plus utilisée est s (substitution) :

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

Élément	Signification
s	Commande de substitution
/	Délimiteur (peut être #, @, |)
ancien	Texte ou regex à rechercher
nouveau	Texte de remplacement

Glissez pour voir

Par défaut, seule la première occurrence par ligne est remplacée. Pour remplacer toutes les occurrences, ajoutez le flag g :

sed 's/foo/bar/g' fichier.txt

Les autres commandes principales

Au-delà de la substitution, sed dispose d'une poignée de commandes d'une seule lettre. Deux d'entre elles se comportent différemment des autres : p duplique la ligne au lieu de l'afficher seule, parce que sed imprime déjà chaque ligne par défaut ; on l'accompagne donc systématiquement de l'option -n. Et q interrompt la lecture du fichier, ce qui en fait la commande la plus efficace pour extraire les premières lignes d'un fichier de plusieurs gigaoctets.

Commande	Effet	Exemple
d	Supprime la ligne	/debug/d
p	Affiche la ligne	-n '/error/p'
i\texte	Insère avant la ligne	1i\# En-tête
a\texte	Ajoute après la ligne	$a\# Fin
c\texte	Remplace la ligne entière	3c\Nouvelle ligne
q	Quitte après cette ligne	10q

Glissez pour voir

Les adresses : cibler des lignes spécifiques

Par défaut, sed applique la commande à toutes les lignes. On peut cibler avec des adresses :

Adresse	Ce qu'elle cible	Exemple
5	Ligne numéro 5	sed '5d' f.txt
$	Dernière ligne	sed '$d' f.txt
/pattern/	Lignes contenant "pattern"	sed '/error/d' f.txt
1,10	Lignes 1 à 10	sed '1,10d' f.txt
/début/,/fin/	Plage entre deux patterns	sed '/BEGIN/,/END/d' f.txt

Glissez pour voir

Les flags de substitution

Les flags se placent après le dernier délimiteur et se cumulent (gi remplace partout sans tenir compte de la casse). Le flag numérique est le moins connu et le plus utile sur des logs : s/a/X/2 ne touche que la deuxième occurrence de chaque ligne. Il se combine d'ailleurs avec g sous la forme s/a/X/2g, qui remplace à partir de la deuxième occurrence jusqu'à la fin de la ligne. Attention au flag i : c'est une extension GNU, absente de POSIX.

Flag	Effet	Exemple
g	Global (toutes occurrences)	s/a/b/g
i	Insensible à la casse	s/error/warning/gi
p	Affiche si substitution faite	-n 's/a/b/p'
2	Remplace la 2ème occurrence	s/a/b/2

Glissez pour voir

Les délimiteurs alternatifs

Quand le texte contient des /, utilisez un autre délimiteur. Le caractère placé juste après le s devient le délimiteur, quel qu'il soit : sed ne réserve rien au slash. Comparez les deux formes ci-dessous, elles font strictement la même chose ; seule la seconde reste relisible dans six mois.

# ✗ Illisible et source d'erreurs
sed 's/\/var\/log/\/opt\/logs/g' fichier.txt

# ✓ Beaucoup plus clair avec #
sed 's#/var/log#/opt/logs#g' fichier.txt

L'édition en place avec -i

Par défaut, sed affiche le résultat sur stdout sans modifier le fichier. Pour modifier directement :

# Modifie le fichier (DANGER si erreur)
sed -i 's/old/new/g' fichier.txt

# ✓ Crée un backup avant modification
sed -i.bak 's/old/new/g' fichier.txt

Règle d'or : toujours tester sans -i d'abord !

# 1. Tester
sed 's/old/new/g' fichier.txt

# 2. Vérifier le résultat, puis seulement :
sed -i.bak 's/old/new/g' fichier.txt

Erreurs typiques (et solutions)

Ces quatre erreurs représentent la majorité des tickets « mon sed ne marche pas ». Toutes se diagnostiquent de la même façon : relancer la commande sans -i et regarder la sortie. Le cas le plus trompeur est le dernier, « rien ne se passe » : sed ne signale jamais l'absence de correspondance et renvoie un code de retour 0, donc un script qui ne vérifie pas son résultat continue comme si la modification avait eu lieu.

Erreur	Cause	Solution
Seule la 1ère occurrence est remplacée	Oubli du flag g	Ajouter g : s/old/new/g
Erreur de syntaxe avec des chemins	/ dans le texte	Utiliser # comme délimiteur
Fichier modifié par erreur	-i sans test préalable	Toujours tester sans -i d'abord
Rien ne se passe	Pas de match (casse ?)	Vérifier avec grep ou utiliser i (insensible)

Glissez pour voir

Les modèles de substitution courants

Maintenant que vous comprenez la logique de sed, voici seize modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Substitution simple

Remplacer la première occurrence d'un texte sur chaque ligne. C'est la forme de base, et aussi le piège le plus courant : sans le flag g, les occurrences suivantes de la même ligne restent intactes.

sed 's/ancien/nouveau/' <fichier>     # formule
sed 's/erreur/warning/' log.txt       # exemple

• ancien : texte ou regex à rechercher
• nouveau : texte de remplacement

Substitution globale

Remplacer toutes les occurrences sur chaque ligne. Le flag g agit à l'intérieur d'une ligne, pas sur l'ensemble du fichier : sed traite déjà toutes les lignes par défaut.

sed 's/ancien/nouveau/g' <fichier>   # formule
sed 's/foo/bar/g' fichier.txt        # exemple

• g : flag global, toutes les occurrences de la ligne

Substitution insensible à la casse

Remplacer un texte quelle que soit la casse. Ce flag est une extension GNU absente de POSIX, donc à éviter dans un script destiné à tourner sur macOS ou sur un système embarqué.

sed 's/ancien/nouveau/gi' <fichier>     # formule
sed 's/error/warning/gi' log.txt        # exemple

• i : flag insensible à la casse (GNU sed)

Délimiteur alternatif

Éviter les échappements quand le texte contient des /. Choisissez un caractère absent du motif comme du remplacement, sinon vous déplacez le problème au lieu de le résoudre.

sed 's#ancien#nouveau#g' <fichier>            # formule
sed 's#/var/log#/opt/logs#g' paths.txt        # exemple

• # : délimiteur alternatif (#, @, etc.) à la place de /

Supprimer des lignes par motif

Supprimer les lignes contenant un motif. La suppression porte sur la ligne entière dès qu'une correspondance est trouvée n'importe où dedans, pas seulement en début de ligne.

sed '/motif/d' <fichier>     # formule
sed '/DEBUG/d' log.txt       # exemple

• motif : pattern regex à reconnaître
• d : commande delete

Supprimer les lignes vides

Nettoyer un fichier en retirant les lignes vides. Attention, ^$ ne reconnaît que les lignes strictement vides : une ligne contenant un espace ou une tabulation survit, il faut alors /^[[:space:]]*$/d.

sed '/^$/d' <fichier>      # formule
sed '/^$/d' texte.txt      # exemple

• ^$ : regex d'une ligne vide (début = fin)

Cibler par numéro de ligne

Appliquer une commande uniquement sur une ligne précise. Le numéro se compte sur l'ensemble des fichiers passés en argument, pas par fichier : avec plusieurs fichiers, la ligne 5 n'existe qu'une fois.

sed 'N<commande>' <fichier>   # formule
sed '5d' fichier.txt          # exemple : supprime la ligne 5

• N : numéro de ligne ciblé

Plage de lignes

Appliquer une commande sur un ensemble de lignes. Les deux bornes sont incluses, et $ peut remplacer la borne haute pour aller jusqu'à la fin du fichier (2,$d).

sed 'N,M<commande>' <fichier>   # formule
sed '2,5d' fichier.txt          # exemple : supprime les lignes 2 à 5

• N,M : de la ligne N à la ligne M incluses

Plage entre deux motifs

Cibler les lignes situées entre deux patterns. Les deux lignes délimitantes sont incluses dans la plage. Si le motif de fin n'apparaît jamais, la plage court jusqu'à la fin du fichier.

sed '/début/,/fin/<commande>' <fichier>     # formule
sed '/BEGIN/,/END/d' fichier.txt            # exemple

• /début/,/fin/ : plage délimitée par deux motifs

Édition en place

Modifier directement le fichier. Aucune confirmation n'est demandée et aucun retour en arrière n'est possible : exécutez toujours la commande sans -i d'abord pour vérifier la sortie.

sed -i '<commande>' <fichier>          # formule
sed -i 's/old/new/g' config.conf       # exemple

• -i : in-place, modifie le fichier. Toujours tester sans -i d'abord.

Édition en place avec sauvegarde

Modifier un fichier en conservant une copie de secours. Le suffixe est collé à l'option, sans espace : -i.bak fonctionne, -i .bak échoue en traitant .bak comme un nom de fichier.

sed -i.bak '<commande>' <fichier>           # formule
sed -i.bak 's/old/new/g' config.conf        # exemple

• -i.bak : crée fichier.bak avant de modifier

Insérer une ligne

Ajouter du texte avant une ligne. La forme condensée sur une seule ligne est une extension GNU ; la version POSIX impose un retour à la ligne après l'antislash.

sed '<adresse>i\<texte>' <fichier>            # formule
sed '1i\# En-tête ajouté' fichier.txt         # exemple

• i\ : commande insert, ajoute avant la ligne ciblée

Ajouter après une ligne

Ajouter du texte après une ligne. Combinée à l'adresse $, elle ajoute une ligne en fin de fichier, geste utile pour compléter une configuration sans l'ouvrir dans un éditeur.

sed '<adresse>a\<texte>' <fichier>             # formule
sed '/END/a\# Commentaire' fichier.txt         # exemple

• a\ : commande append, ajoute après la ligne ciblée

Afficher uniquement les lignes correspondantes

Extraire les lignes d'un motif, comme grep. L'option -n est indissociable de p : sans elle, sed affiche déjà chaque ligne et les lignes reconnues apparaissent en double.

sed -n '/motif/p' <fichier>     # formule
sed -n '/ERROR/p' log.txt       # exemple

• -n : désactive l'affichage automatique
• p : commande print, affiche la ligne

Références arrière (groupes capturés)

Réutiliser une partie capturée dans le remplacement. En regex basique, les parenthèses de groupe s'échappent (\( et \)) ; avec l'option -E, elles s'écrivent sans antislash.

sed 's/\(motif\)/\1 ajout/' <fichier>          # formule
sed 's/\([0-9]*\)/ID:\1/' fichier.txt          # exemple

• \(\) : groupe de capture
• \1 : référence au premier groupe capturé

Réutiliser le texte correspondant (&)

Insérer le texte reconnu dans le remplacement. Pour insérer un & littéral, échappez-le en \&, sinon sed recopie le texte reconnu à la place.

sed 's/motif/[&]/g' <fichier>            # formule
sed 's/[0-9]\+/(&)/g' fichier.txt        # exemple

• & : représente l'intégralité du texte reconnu

Les pièges à éviter

Sept erreurs reviennent constamment avec sed. Pour chacune : la commande piégée, le symptôme, la cause et la correction.

Oubli du flag g

sed 's/foo/bar/' fichier.txt   # ✗ ne remplace que la 1ʳᵉ occurrence par ligne

Symptôme : certaines occurrences ne sont pas remplacées. Cause : sans g, sed ne touche que la première occurrence de chaque ligne.

sed 's/foo/bar/g' fichier.txt   # ✓ flag global

Slash dans le texte à remplacer

sed 's//var/log//opt/logs/' fichier.txt   # ✗ erreur de syntaxe

Symptôme : erreur unknown command ou résultat inattendu. Cause : les / du texte sont pris pour des délimiteurs.

sed 's#/var/log#/opt/logs#g' fichier.txt   # ✓ délimiteur alternatif

Édition -i sans prévisualisation

sed -i 's/important/supprimé/g' fichier.conf   # ✗ exécuté sans test

Symptôme : données perdues, fichier corrompu. Cause : -i modifie le fichier sans retour arrière possible.

sed 's/old/new/g' fichier   # ✓ tester d'abord, puis sed -i.bak

Métacaractère regex non échappé

sed 's/fichier.txt/fichier.log/' fichier   # ✗ le . matche n'importe quel caractère

Symptôme : des correspondances inattendues (fichierXtxt est aussi reconnu). Cause : le point . est un métacaractère regex.

sed 's/fichier\.txt/fichier.log/g' fichier   # ✓ point échappé

Incompatibilité -i entre GNU et BSD

sed -i 's/old/new/' fichier   # ✗ échoue sur macOS (BSD sed)

Symptôme : erreur invalid command code sur macOS. Cause : BSD sed exige une extension après -i, même vide.

sed -i '' 's/old/new/' fichier   # ✓ sur macOS, ou installer GNU sed

Saut de ligne dans le remplacement

sed 's/$/\n/' fichier   # ✗ marche avec GNU sed, pas garanti ailleurs

Symptôme : la commande produit bien une ligne vide après chaque ligne sur un serveur Linux, puis un n littéral apparaît sur le poste macOS d'un collègue. Cause : POSIX ne définit pas le sens de \n dans la partie remplacement. GNU sed l'interprète comme un vrai saut de ligne, les implémentations BSD ne le garantissent pas. Pour un script qui doit tourner partout, on injecte le saut de ligne depuis le shell.

sed 's/$/\'$'\n''/' fichier   # ✓ portable : le saut de ligne vient de bash ($'\n')

Regex gourmande (.* trop large)

sed 's/<.*>//g' fichier   # ✗ supprime du premier < au dernier >

Symptôme : <a>texte<b> devient vide au lieu de texte. Cause : .* est gourmand, il reconnaît le maximum possible.

sed 's/<[^>]*>//g' fichier   # ✓ classe négative : s'arrête au premier >

sed -i casse les liens symboliques

sed -i 's/old/new/' /etc/service/config   # ✗ si config est un symlink, le lien saute

Symptôme : le lien symbolique disparaît, remplacé par un fichier classique, et la cible d'origine reste inchangée. Cause : -i écrit un fichier temporaire puis le renomme sur le chemin, ce qui détruit le lien.

sed -i --follow-symlinks 's/old/new/' /etc/service/config   # ✓ GNU : suit le lien

Le faux-ami \d

sed 's/\d/X/g' fichier   # ✗ \d ne signifie PAS « chiffre » dans sed

Symptôme : des lettres sont remplacées au lieu des chiffres (\d reconnaît la lettre d). Cause : contrairement aux regex PCRE, sed ne connaît pas \d. Solution : la classe POSIX, portable.

sed 's/[[:digit:]]/X/g' fichier   # ✓ ou [0-9]

Fins de ligne Windows (CRLF)

sed 's/local$/remote/' config.txt   # ✗ échoue si le fichier est en CRLF

Symptôme : aucun remplacement alors que le motif paraît correct. Cause : un \r invisible reste en fin de ligne, donc l'ancre $ matche avant lui. Solution : retirer le \r d'abord.

sed 's/\r$//' config.txt   # ✓ normalise en LF (GNU)

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les huit étapes. À la fin, nettoyez avec rm -rf ~/sed-lab.

Préparer le terrain

Ce script crée cinq fichiers de test dans ~/sed-lab : une configuration, un log, un CSV, une liste de chemins et un fichier « brouillon » à nettoyer.

# Créer le lab
mkdir -p ~/sed-lab
cd ~/sed-lab

# Fichier de configuration type
cat > config.conf << 'EOF'
# Configuration serveur
server_host=localhost
server_port=8080
debug_mode=true
log_level=INFO
database_url=postgres://localhost:5432/mydb
max_connections=100
EOF

# Fichier de logs
cat > access.log << 'EOF'
192.168.1.10 - - [15/Jan/2025:10:30:00] "GET /index.html HTTP/1.1" 200 1234
192.168.1.20 - - [15/Jan/2025:10:30:05] "POST /api/users HTTP/1.1" 201 567
192.168.1.10 - - [15/Jan/2025:10:30:10] "GET /style.css HTTP/1.1" 200 890
192.168.1.30 - - [15/Jan/2025:10:30:15] "GET /error HTTP/1.1" 404 123
192.168.1.10 - - [15/Jan/2025:10:30:20] "DELETE /api/users/5 HTTP/1.1" 403 45
EOF

# Fichier CSV
cat > users.csv << 'EOF'
id,nom,email,role
1,Alice,alice@example.com,admin
2,Bob,bob@example.com,user
3,Charlie,charlie@example.com,user
4,Diana,diana@example.com,moderator
EOF

# Fichier avec chemins
cat > paths.txt << 'EOF'
/var/log/syslog
/home/user/documents/report.pdf
/etc/nginx/nginx.conf
/usr/local/bin/script.sh
EOF

# Fichier à nettoyer
cat > messy.txt << 'EOF'
  Ligne avec espaces au début
Ligne normale
   Autre ligne avec espaces
Ligne vide après

Encore du texte
  Espaces partout
EOF

echo "✓ Lab créé dans ~/sed-lab"
ls -la ~/sed-lab

Les huit étapes

Ces huit commandes s'exécutent sans -i sauf la septième : elles affichent le résultat à l'écran et laissent les fichiers du lab intacts. Prenez l'habitude de comparer la sortie au fichier d'origine avec diff <(sed ...) fichier avant de passer à l'étape suivante. La progression va du remplacement simple vers le ciblage par adresse, qui est la vraie compétence à acquérir : savoir restreindre une transformation à quelques lignes évite les dégâts sur les fichiers de configuration.

1. Substitution simple. Remplacez localhost par 127.0.0.1 dans config.conf.

   sed 's/localhost/127.0.0.1/' ~/sed-lab/config.conf

   s/ancien/nouveau/ remplace la première occurrence sur chaque ligne. Pour toutes les occurrences : ajoutez le flag g.

2. Délimiteur alternatif. Remplacez /var/log par /opt/logs dans paths.txt.

   sed 's#/var/log#/opt/logs#' ~/sed-lab/paths.txt

   Quand le texte contient des /, on utilise un autre délimiteur (# ici).

3. Supprimer des lignes. Supprimez les lignes contenant 404 dans access.log.

   sed '/404/d' ~/sed-lab/access.log

   /motif/d supprime les lignes qui contiennent le motif.

4. Supprimer les lignes vides. Retirez les lignes vides de messy.txt.

   sed '/^$/d' ~/sed-lab/messy.txt

   ^$ reconnaît une ligne vide (début immédiatement suivi de la fin).

5. Cibler une ligne par numéro. Remplacez user par admin uniquement sur la ligne 3 de users.csv.

   sed '3s/user/admin/' ~/sed-lab/users.csv

   Le numéro placé avant la commande la restreint à cette ligne.

6. Plage de lignes. Remplacez @example.com par @company.org sur les lignes 2 à 4 de users.csv.

   sed '2,4s/@example.com/@company.org/' ~/sed-lab/users.csv

   N,M cible les lignes de N à M incluses.

7. Édition en place avec sauvegarde. Modifiez config.conf en remplaçant true par false, en gardant une sauvegarde.

   sed -i.bak 's/true/false/' ~/sed-lab/config.conf

   -i.bak modifie le fichier et crée config.conf.bak au préalable.

8. Supprimer les espaces en début de ligne. Retirez les espaces au début de chaque ligne de messy.txt.

   sed 's/^[[:space:]]*//' ~/sed-lab/messy.txt

   ^[[:space:]]* reconnaît zéro espace ou plus en début de ligne.

Exercices progressifs

Huit exercices pour valider votre maîtrise. Tous se traitent sur les fichiers du lab ~/sed-lab. Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Ces trois premiers exercices ne mobilisent qu'une commande à la fois : substituer, changer de délimiteur, supprimer des lignes. Écrivez votre réponse avant d'ouvrir la solution, puis exécutez-la sur le lab : une commande qui semble juste sur le papier échoue souvent sur un détail de délimiteur ou d'échappement.

Exercice 1, Substitution basique. Remplacez tous les error par warning dans access.log. Indice : n'oubliez pas le flag g.

Voir la solution

sed 's/error/warning/g' ~/sed-lab/access.log

Le flag g remplace toutes les occurrences, pas seulement la première de chaque ligne.

Exercice 2, Remplacer des chemins. Remplacez /usr/local par /opt dans paths.txt. Indice : les / du texte gênent le délimiteur par défaut.

Voir la solution

sed 's#/usr/local#/opt#g' ~/sed-lab/paths.txt

On utilise # comme délimiteur pour éviter d'échapper les /.

Exercice 3, Supprimer les commentaires. Supprimez toutes les lignes commençant par # dans config.conf. Indice : ^ représente le début de ligne, d supprime.

Voir la solution

sed '/^#/d' ~/sed-lab/config.conf

/^#/ reconnaît les lignes commençant par # ; d les supprime.

Niveau composition

Les trois exercices suivants combinent une regex et une adresse. C'est le passage difficile : il faut décrire une position (fin de ligne, numéro de ligne) et non plus seulement un mot. Si votre commande ne renvoie rien, vérifiez d'abord le motif seul avec grep avant d'incriminer sed.

Exercice 4, Nettoyer les espaces. Supprimez les espaces en fin de ligne de messy.txt. Indice : [[:space:]] reconnaît les espaces, $ la fin de ligne.

Voir la solution

sed 's/[[:space:]]*$//' ~/sed-lab/messy.txt

[[:space:]]*$ reconnaît zéro espace ou plus juste avant la fin de ligne.

Exercice 5, Modifier une ligne précise. Changez le contenu entier de la ligne 3 de users.csv en MODIFIÉ. Indice : c\ remplace toute une ligne.

Voir la solution

sed '3c\MODIFIÉ' ~/sed-lab/users.csv

3c\ cible la ligne 3 ; c\ remplace son contenu entier.

Exercice 6, Extraire des lignes (comme grep). Affichez uniquement les lignes d'access.log contenant 404. Indice : -n désactive l'affichage auto, p affiche les lignes reconnues.

Voir la solution

sed -n '/404/p' ~/sed-lab/access.log

-n coupe l'affichage par défaut ; /404/p n'affiche que les lignes correspondantes.

Niveau avancé

Les deux derniers exercices touchent aux gestes qu'on retrouve dans les scripts de production : préfixer un flux et modifier un fichier en place. Le second est le seul de la série qui écrit sur le disque ; vérifiez la présence du fichier .bak après exécution, c'est la preuve que le filet de sécurité a bien fonctionné.

Exercice 7, Ajouter un préfixe à chaque ligne. Ajoutez LOG: au début de chaque ligne d'access.log. Indice : ^ reconnaît le début de ligne.

Voir la solution

sed 's/^/LOG: /' ~/sed-lab/access.log

s/^/LOG: / remplace le « début de ligne » par LOG: , donc préfixe chaque ligne.

Exercice 8, Édition en place sécurisée. Remplacez localhost par 127.0.0.1 dans config.conf en conservant une sauvegarde. Indice : -i.bak crée la sauvegarde automatiquement.

Voir la solution

sed -i.bak 's/localhost/127.0.0.1/g' ~/sed-lab/config.conf

-i.bak modifie le fichier en place et crée config.conf.bak comme filet de sécurité.

Dépannage

Quand une substitution sed ne fonctionne pas, le problème vient le plus souvent du motif ou des délimiteurs. Voici comment diagnostiquer.

Méthodes de diagnostic

Ces quatre commandes se lancent dans l'ordre : elles isolent progressivement l'origine du problème. La troisième, sed -n '/pattern/=', affiche les numéros de ligne reconnus et répond à la seule question qui compte au départ : le motif reconnaît-il quelque chose ? Si elle ne renvoie rien, le problème est dans la regex, pas dans la substitution. Si elle renvoie des numéros mais que le remplacement n'apparaît pas, l'erreur est dans la partie droite du s///.

# Toujours prévisualiser avant d'utiliser -i
sed 's/old/new/g' fichier

# Voir quelles lignes sont reconnues par un motif
sed -n '/pattern/p' fichier

# Afficher les numéros des lignes reconnues
sed -n '/pattern/=' fichier

# Valider le motif isolément avec grep
grep 'pattern' fichier

Erreurs fréquentes

Contrairement à l'absence de correspondance, ces quatre situations produisent un message d'erreur explicite et un code de retour non nul, donc un script avec set -e s'arrête dessus. Lisez le message en entier : sed indique le numéro de caractère fautif dans l'expression, ce qui localise immédiatement le délimiteur manquant.

Message d'erreur	Cause probable	Solution
unterminated 's' command	Délimiteur de fermeture manquant, ou / non échappé dans le texte	S'assurer d'avoir exactement 3 délimiteurs : s/ancien/nouveau/
unknown option -- E	Option non supportée (BSD sed contre GNU sed)	Vérifier sed --version ; sur macOS, installer GNU sed
no input files	Aucun fichier fourni et aucune entrée standard	Passer un fichier en argument, ou utiliser un pipe
invalid command code	Commande sed inconnue, ou problème de guillemets	Vérifier la lettre de commande et les guillemets simples

Glissez pour voir

sed dans les workflows DevOps

sed est partout dans l'automatisation, mais quelques réflexes évitent des incidents en CI et en gestion de configuration.

Le piège GNU contre BSD en CI

sed -i 's/a/b/' fichier fonctionne sur Linux (GNU sed) mais échoue sur macOS (BSD sed), où -i attend un suffixe de sauvegarde juste après. Un pipeline qui tourne à la fois sur des runners Linux et macOS doit utiliser une forme portable :

sed -i.bak 's/a/b/' fichier && rm fichier.bak   # portable GNU + BSD
# ou, encore plus robuste :
perl -pi -e 's/a/b/' fichier

sed -i n'est pas idempotent : préférez Ansible

En gestion de configuration, un sed -i lancé via le module shell est rejoué à chaque exécution et rapporte toujours changed : Ansible ne peut pas savoir si la modification est déjà appliquée, et un ajout de ligne finit par se dupliquer. Pour éditer un fichier de configuration durablement, les modules lineinfile et replace sont déclaratifs et idempotents, gèrent --check/--diff et créent une sauvegarde. Gardez sed pour les transformations ponctuelles, pas pour l'état d'un serveur.

Conteneurs et templating

Dans un Dockerfile, un RUN sed -i fige la modification dans une couche d'image. Préférez configurer au runtime (ENV, variables, script d'entrée) pour qu'une seule image serve tous les environnements. Pour injecter des variables dans un fichier (${VAR}), envsubst est plus sûr que sed (ni problème de délimiteur, ni risque d'injection) ; dès qu'il faut des conditions ou des boucles, passez à un vrai moteur de templates comme Jinja2.

Aide-mémoire sed

Les cinq tableaux qui suivent regroupent ce qui sert au quotidien, classé par nature : options, adresses, commandes, regex, délimiteurs. Les entrées marquées GNU n'existent pas sur macOS ni sur les BusyBox embarquées, à vérifier avant de les glisser dans un script partagé.

Syntaxe et options

Les options se placent avant la commande. Retenez le couple -n et p : c'est la combinaison qui transforme sed en outil d'extraction. L'option -E mérite aussi votre attention, car elle bascule vers les regex étendues et supprime les échappements pénibles : \(...\) devient (...), et \+ devient +.

Élément	Rôle	Exemple
sed 'cmd' fichier	Applique une commande au fichier	sed 's/a/b/' f.txt
sed -e 'cmd1' -e 'cmd2'	Enchaîne plusieurs commandes	sed -e 's/a/b/' -e 's/c/d/'
cmd | sed 'cmd'	Traite l'entrée d'un pipe	cat f.txt | sed 's/a/b/'
-i	Édition en place (modifie le fichier)	sed -i 's/a/b/' f.txt
-i.bak	Édition en place avec sauvegarde	sed -i.bak 's/a/b/' f.txt
-n	Mode silencieux (rien par défaut)	sed -n '/err/p' f.txt
-E (ou -r)	Active les regex étendues (ERE)	sed -E 's/[0-9]+/X/g'
-f script.sed	Lit les commandes depuis un fichier	sed -f cmds.sed fichier

Glissez pour voir

Adresses (ciblage)

L'adresse se place devant la commande et restreint son champ d'action. Une seule entrée du tableau est une extension GNU absente de POSIX : 1~2, qui sélectionne une ligne sur deux. La négation ! est en revanche standard, et c'est la plus utile en pratique : /DEBUG/!d conserve uniquement les lignes de débogage, ce qui évite d'écrire la regex inverse, souvent impossible à formuler proprement.

Adresse	Rôle	Exemple
5	Ligne numéro 5	5s/a/b/
$	Dernière ligne	$d
/regex/	Lignes reconnues par la regex	/error/d
1,10	Lignes 1 à 10	1,10s/a/b/
/début/,/fin/	Plage entre deux motifs	/BEGIN/,/END/d
1~2	Ligne 1 puis une sur deux (GNU)	1~2d
!	Inverse l'adresse (NON)	/DEBUG/!d

Glissez pour voir

Commandes principales

Les trois commandes d'insertion i\, a\ et c\ sont celles qui posent le plus de problèmes de portabilité : GNU accepte le texte sur la même ligne (1i\# Header), alors que la forme POSIX stricte impose un retour à la ligne après l'antislash. Si un script d'insertion échoue sur un autre système, c'est presque toujours de là que vient le problème.

Commande	Rôle	Exemple
s/old/new/	Substitue (1ʳᵉ occurrence)	s/error/warning/
s/old/new/g	Substitue (toutes les occurrences)	s/foo/bar/g
s/old/new/gi	Substitue sans tenir compte de la casse	s/error/warning/gi
d	Supprime la ligne	/^#/d
p	Affiche la ligne	-n '/error/p'
q	Quitte après cette ligne	10q
=	Affiche le numéro de ligne	/error/=
i\texte	Insère une ligne avant	1i\# Header
a\texte	Ajoute une ligne après	$a\# Footer
c\texte	Remplace la ligne entière	3c\Nouvelle ligne

Glissez pour voir

Regex et références

sed utilise par défaut les regex basiques (BRE), pas la syntaxe PCRE des langages de programmation. Concrètement, les parenthèses de groupe s'écrivent \(...\) et non (...). GNU accepte bien \w et \s, mais ce sont des extensions non portables, et \d n'y signifie pas « chiffre » : préférez les classes POSIX [[:digit:]], [[:alnum:]] et [[:space:]], qui fonctionnent sur toutes les implémentations. L'option -E bascule en regex étendues et rétablit les parenthèses sans antislash.

Élément	Rôle	Exemple
&	Le texte reconnu, dans le remplacement	s/[0-9]*/(&)/
\1, \2…	Groupes capturés	s/\(.*\)/[\1]/
\(\)	Groupe de capture (regex basique)	s/\(mot\)/[\1]/
^ / $	Début / fin de ligne	s/^/PREFIX: /
.	N'importe quel caractère	s/a.c/X/
[abc] / [^abc]	Classe / négation de classe	s/[^0-9]//g

Glissez pour voir

Délimiteurs alternatifs

Le caractère qui suit immédiatement le s devient le délimiteur : sed n'impose pas le /, c'est une simple convention. Choisissez un caractère absent du motif et du remplacement, sinon vous revenez au problème de départ. Le # convient aux chemins de fichiers, le @ ou le , aux URL contenant des //. Un délimiteur bien choisi supprime tous les antislashs et rend la commande relisible six mois plus tard.

Forme	Rôle	Exemple
s#old#new#	Délimiteur # (idéal pour les chemins)	s#/var#/opt#g
s@old@new@	Délimiteur @	s@http://@https://@g
s|old|new|	Délimiteur |	s|foo|bar|g

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez sed lorsque vous pouvez cocher chacun de ces points :

• Je sais utiliser s/ancien/nouveau/ pour substituer
• Je sais utiliser le flag g pour remplacer globalement
• Je sais utiliser un délimiteur alternatif (#, @)
• Je sais supprimer des lignes avec d
• Je sais cibler des lignes par numéro ou par motif
• Je sais utiliser -n et p pour extraire des lignes
• Je sais éditer en place avec -i et -i.bak
• Je sais insérer ou ajouter une ligne avec i\ et a\
• Je sais utiliser les références arrière (\1, &)
• Je sais diagnostiquer une substitution qui ne fonctionne pas

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• sed édite du texte plat ligne par ligne : substitution s///, suppression d, adresses pour cibler.
• Le flag g remplace toutes les occurrences d'une ligne ; sans lui, seulement la première.
• Toujours prévisualiser sans -i, puis -i.bak pour garder un filet de sécurité.
• Pour de la donnée structurée, changez d'outil : jq (JSON), yq (YAML), awk ou perl (multi-ligne).
• En CI, méfiez-vous du GNU contre BSD (-i) ; en gestion de configuration, préférez Ansible lineinfile (idempotent).
• Pièges classiques : symlink cassé par -i, faux-ami \d, fins de ligne CRLF.

FAQ - Questions Fréquemment Posées

Qu'est-ce que la commande sed sous Linux ?

La commande sed est un éditeur de flux (stream editor) qui permet de rechercher, remplacer, supprimer ou insérer du texte directement en ligne de commande, sans ouvrir le fichier manuellement.

À quoi sert sed concrètement ?

Sed est utilisé pour modifier rapidement le contenu de fichiers texte : remplacer des mots, supprimer des lignes spécifiques, insérer ou ajouter du texte, et automatiser des traitements massifs dans des fichiers de configuration, des logs ou des exports texte.

Quelle est la syntaxe de base de sed ?

La syntaxe de base est : sed [options] 'commande' [fichier], où la commande peut être par exemple s (substitution), d (suppression), i (insertion), ou a (ajout).

Comment faire une substitution simple avec sed ?

On utilise la commande s, par exemple : sed 's/ancien/nouveau/' fichier.txt, qui remplace la première occurrence de 'ancien' par 'nouveau' sur chaque ligne.

Comment remplacer toutes les occurrences sur une ligne ?

On ajoute le modificateur g à la commande, par exemple : sed 's/erreur/avertissement/g' fichier.log, ce qui remplace toutes les occurrences sur chaque ligne.

Comment supprimer une ligne spécifique avec sed ?

Pour supprimer une ligne précise, on utilise la commande d avec le numéro de ligne : sed '3d' fichier.txt supprime la troisième ligne.

Comment supprimer les lignes contenant un motif précis ?

Il suffit d'utiliser : sed '/motif/d' fichier.txt. Par exemple, sed '/erreur/d' fichier.log supprime toutes les lignes contenant le mot 'erreur'.

Comment insérer du texte avant une ligne spécifique ?

On utilise la commande i. Exemple : sed '1i\# Entête ajoutée' fichier.txt insère la ligne avant la première ligne du fichier.

Comment ajouter du texte après une ligne spécifique ?

On utilise la commande a. Par exemple : sed '3a\Texte ajouté' fichier.txt ajoute la ligne après la troisième ligne.

Comment remplacer entièrement une ligne spécifique ?

La commande c permet de remplacer une ligne entière. Exemple : sed '5c\Nouvelle ligne' fichier.txt remplace la cinquième ligne par 'Nouvelle ligne'.

Comment appliquer les modifications directement dans le fichier ?

L'option -i permet l'édition en place. Exemple : sed -i 's/old/new/g' fichier.txt applique la modification directement dans le fichier sans passer par la sortie standard.

Comment créer une sauvegarde avant de modifier un fichier avec sed ?

On utilise -i avec une extension de sauvegarde : sed -i.bak 's/old/new/g' fichier.txt crée une copie fichier.txt.bak avant modification.

Peut-on utiliser sed avec des expressions régulières ?

Oui, sed supporte les expressions régulières pour rechercher des motifs complexes. Exemple : sed 's/^[0-9]/#/g' fichier.txt ajoute un # au début des lignes qui commencent par un chiffre.

Comment regrouper plusieurs commandes sed dans un fichier ?

On crée un fichier contenant plusieurs commandes sed, puis on l'exécute avec : sed -f script.sed fichier.txt.

Quels sont les cas d'usage les plus courants de sed ?

Sed est utilisé pour nettoyer des logs, modifier des fichiers de configuration, mettre à jour des chemins dans des scripts, reformater des CSV, ou injecter du contenu dans des templates HTML ou autres.

×

📖 Voir la documentation →