sed : transformer du texte à la volée

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' {} +

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

sed [OPTIONS] 'COMMANDE' [FICHIER]

Les 3 parties d'une commande sed

La commande sed suit une logique simple :

É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

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

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 :

# ❌ 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)

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.

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.

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.

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 /.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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   # ❌ insère un \n littéral, pas un vrai saut de ligne

Symptôme : un \n littéral apparaît au lieu d'un retour à la ligne. Cause : la syntaxe \n n'est pas portable dans la partie remplacement.

sed 's/$/\'$'\n''/' fichier   # ✅ en bash, via $'\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 >

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

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

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

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é

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

# 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

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

Aide-mémoire sed

Syntaxe et options

É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)

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

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

É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

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

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

10 questions

5 min.

80% 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

Conclusion

La commande sed est un outil essentiel pour quiconque travaille régulièrement en ligne de commande. Grâce à sa syntaxe concise et sa capacité à traiter des flux de texte, elle permet de modifier, nettoyer et transformer du contenu rapidement et efficacement. Que ce soit pour un remplacement ponctuel, un nettoyage de logs ou une modification en masse de fichiers de configuration, la maîtrise de sed fait gagner un temps précieux.

Articles qui pourraient vous intéresser

• Maîtriser awk pour le traitement de données
• Maîtriser grep pour la recherche de patterns
• Maîtriser find pour la recherche de fichiers
• Personnaliser Bash : .bashrc, alias et prompt

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 →