image/svg+xml JaaJBlog

Sed : éditer des fichiers en ligne de commande avec des regex

 
  • Pierre Chopinet
  • 19 Jan, 2026

sed (Stream EDitor) est un outil en ligne de commande pour éditer des flux de texte avec des expressions régulières. Indispensable pour les opérations de recherche/remplacement, suppression de lignes, insertion, et transformations sur fichiers ou flux stdin.

Objectifs de l’article :

  • Comprendre la syntaxe de base de sed
  • Maîtriser les commandes essentielles (substitution, suppression, insertion, modification)
  • Utiliser les expressions régulières avec sed
  • Découvrir 15 cas pratiques du quotidien
  • Connaître les options importantes (-i, -n, -e, -r/-E)

Installation

sed est préinstallé sur la plupart des systèmes Unix/Linux. Sur macOS, la version BSD est installée par défaut (syntaxe légèrement différente).

GNU sed (recommandé)

  • Linux : déjà installé
  • macOS : brew install gnu-sed (commande : gsed)
  • Windows : WSL, Git Bash, ou Cygwin

Vérification :

sed --version
# GNU sed version 4.8 ou supérieur

Syntaxe de base

sed 'commande' fichier.txt              # Affiche le résultat (ne modifie pas le fichier)
sed -i 'commande' fichier.txt           # Modifie le fichier en place
sed -i.bak 'commande' fichier.txt       # Modifie + crée une sauvegarde .bak
sed -e 'cmd1' -e 'cmd2' fichier.txt     # Plusieurs commandes
echo "texte" | sed 'commande'           # Depuis stdin

Structure d’une commande sed :

[adresse]commande[options]
  • adresse : ligne(s) concernée(s) (optionnel, si absent = toutes les lignes)
  • commande : s (substitute), d (delete), p (print), a (append), i (insert), c (change)…

Les commandes essentielles

Substitution : s/pattern/replacement/flags

La commande la plus utilisée. Remplace pattern par replacement.

Flags courants :

  • g : global (toutes les occurrences sur la ligne)
  • i : insensible à la casse
  • 2 : uniquement la 2ème occurrence
  • p : afficher les lignes modifiées
# Remplacer la première occurrence
sed 's/foo/bar/' file.txt

# Remplacer toutes les occurrences
sed 's/foo/bar/g' file.txt

# Insensible à la casse
sed 's/foo/bar/gi' file.txt

Suppression : d

# Supprimer la ligne 3
sed '3d' file.txt

# Supprimer les lignes 2 à 5
sed '2,5d' file.txt

# Supprimer les lignes contenant "error"
sed '/error/d' file.txt

# Supprimer les lignes vides
sed '/^$/d' file.txt

Insertion et ajout : i et a

# Insérer avant la ligne 3
sed '3i\Nouvelle ligne' file.txt

# Ajouter après la ligne 3
sed '3a\Nouvelle ligne' file.txt

# Ajouter après chaque ligne contenant "pattern"
sed '/pattern/a\Ligne ajoutée' file.txt

Remplacement de ligne : c

# Remplacer la ligne 2
sed '2c\Nouveau contenu' file.txt

# Remplacer les lignes contenant "old"
sed '/old/c\Nouveau contenu' file.txt

Affichage sélectif : p avec -n

Par défaut, sed affiche toutes les lignes. -n supprime l’affichage automatique.

# Afficher uniquement la ligne 5
sed -n '5p' file.txt

# Afficher les lignes 10 à 20
sed -n '10,20p' file.txt

# Afficher les lignes contenant "error"
sed -n '/error/p' file.txt

# Équivalent de grep
sed -n '/pattern/p' file.txt  # = grep 'pattern' file.txt

Expressions régulières avec sed

Syntaxe par défaut (BRE - Basic Regular Expressions)

# Caractères spéciaux : . * ^ $ [ ] \
sed 's/^/#/' file.txt              # Commenter toutes les lignes
sed 's/ *$//' file.txt             # Supprimer espaces de fin de ligne
sed 's/[0-9]\+/NUM/g' file.txt     # Remplacer nombres par NUM (BRE: \+)

Extended Regular Expressions (-E ou -r)

Option -E (GNU/BSD moderne) ou -r (GNU ancien) pour utiliser ERE.

# Avec ERE : + ? | () {} sans backslash
sed -E 's/[0-9]+/NUM/g' file.txt           # + sans backslash
sed -E 's/(foo|bar)/baz/g' file.txt        # alternance
sed -E 's/([0-9]{2})-([0-9]{2})/\2-\1/' file.txt  # groupes capturants

Groupes capturants et backreferences

# Inverser deux mots séparés par un espace
sed -E 's/(\w+) (\w+)/\2 \1/' file.txt

# Doubler chaque mot
sed -E 's/\b(\w+)\b/\1 \1/g' file.txt

# Remplacer dates DD/MM/YYYY par YYYY-MM-DD
sed -E 's|([0-9]{2})/([0-9]{2})/([0-9]{4})|\3-\2-\1|g' file.txt

15 cas pratiques

Rechercher et remplacer (comme find & replace)

# Remplacer "http://" par "https://" dans tous les fichiers .txt
find . -name "*.txt" -exec sed -i 's|http://|https://|g' {} +

Commenter/décommenter des lignes

# Commenter les lignes contenant "debug"
sed -i '/debug/s/^/#/' config.txt

# Décommenter les lignes commençant par #debug
sed -i 's/^#\(debug\)/\1/' config.txt

Supprimer les lignes vides

sed -i '/^$/d' file.txt

Supprimer les espaces/tabs en début et fin de ligne

# Début de ligne
sed 's/^[ \t]*//' file.txt

# Fin de ligne
sed 's/[ \t]*$//' file.txt

# Les deux
sed 's/^[ \t]*//; s/[ \t]*$//' file.txt

Remplacer uniquement sur certaines lignes

# Remplacer "foo" par "bar" uniquement lignes 10 à 20
sed '10,20s/foo/bar/g' file.txt

# Remplacer uniquement dans les lignes contenant "section"
sed '/section/s/old/new/g' file.txt

Numéroter les lignes

sed = file.txt | sed 'N; s/\n/\t/'
# ou avec nl (plus simple)
nl file.txt

Afficher les lignes entre deux motifs

# Afficher lignes entre START et END (inclus)
sed -n '/START/,/END/p' file.txt

Supprimer les commentaires

# Supprimer les lignes commençant par #
sed '/^#/d' file.txt

# Supprimer les commentaires # en fin de ligne
sed 's/#.*$//' file.txt

Insérer ou remplacer une ligne par le contenu d’un fichier

Attention : la commande r insère le fichier APRÈS la ligne, sans effacer cette ligne.

# Insérer le contenu de insert.txt APRÈS la ligne 5 (la ligne 5 est conservée)
sed -i '5r insert.txt' file.txt

# Vraiment REMPLACER la ligne 5 par le contenu de insert.txt (lecture puis suppression)
sed -i -e '5{r insert.txt' -e 'd}' file.txt

Extraire des informations avec regex

# Extraire les adresses email
sed -nE 's/.*([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}).*/\1/p' file.txt

# Extraire les URLs
sed -nE 's|.*(https?://[^[:space:]]+).*|\1|p' file.txt

Convertir minuscules/majuscules

# Tout en majuscules
sed 's/.*/\U&/' file.txt

# Tout en minuscules
sed 's/.*/\L&/' file.txt

# Première lettre en majuscule (GNU sed)
sed 's/\b\(.\)/\U\1/g' file.txt

Note : \U, \L sont des extensions GNU sed. Pour BSD/macOS, utilisez tr à la place.

Remplacer les retours à la ligne

# Joindre toutes les lignes en une seule
sed ':a;N;$!ba;s/\n/ /g' file.txt

# Plus simple avec tr
tr '\n' ' ' < file.txt

Doubler l’espacement (ligne vide après chaque ligne)

sed G file.txt

Supprimer les doublons de lignes consécutives

# Comme uniq, mais avec sed
sed '$!N; /^\(.*\)\n\1$/!P; D' file.txt

# Plus simple : sort + uniq
sort file.txt | uniq

Rechercher et remplacer avec délimiteur personnalisé

Utile pour les chemins avec /.

# Au lieu de s/\/old\/path/\/new\/path/g
sed 's|/old/path|/new/path|g' file.txt

# Ou avec #
sed 's#/old/path#/new/path#g' file.txt

Options importantes

-i : Éditer en place (in-place)

# Modifie le fichier directement
sed -i 's/foo/bar/g' file.txt

# Crée une sauvegarde
sed -i.bak 's/foo/bar/g' file.txt

macOS/BSD : -i nécessite un argument (même vide) : sed -i '' 's/foo/bar/g' file.txt

-n : Mode silencieux (suppress automatic printing)

# Afficher uniquement les lignes modifiées
sed -n 's/foo/bar/gp' file.txt

-e : Commandes multiples

sed -e 's/foo/bar/g' -e 's/hello/world/g' file.txt

# Équivalent avec ;
sed 's/foo/bar/g; s/hello/world/g' file.txt

-E ou -r : Extended regex

# GNU sed
sed -E 's/[0-9]+/NUM/g' file.txt

# Ancien GNU / BSD
sed -r 's/[0-9]+/NUM/g' file.txt  # GNU
sed -E 's/[0-9]+/NUM/g' file.txt  # BSD/macOS

-f : Lire les commandes depuis un fichier

# script.sed
s/foo/bar/g
s/hello/world/g
/^#/d

# Exécution
sed -f script.sed file.txt

Différences GNU sed vs BSD sed (macOS)

Fonctionnalité GNU sed BSD sed (macOS)
-i sans backup -i -i ''
Extended regex -E ou -r -E
\+ (BRE) Supporté Non supporté
\U, \L (casse) Supporté Non supporté
-z (NULL) Supporté Non supporté

Conseil macOS : installez GNU sed avec Homebrew (brew install gnu-sed) et utilisez gsed.

Bonnes pratiques

À faire

  • Testez d’abord sans -i : vérifiez le résultat avant de modifier le fichier
  • Créez une sauvegarde : sed -i.bak pour garder l’original
  • Utilisez -E : plus lisible pour les regex complexes
  • Délimiteur alternatif : s|/path|new|g pour les chemins
  • Échappez les caractères spéciaux : \. \* \$ etc.

À éviter

  • Modifier directement sans test (risque de perte de données)
  • Regex trop complexes : préférez awk, perl ou un script Python
  • sed pour du parsing HTML/XML/JSON : utilisez des outils dédiés

Sed vs autres outils

Outil Usage
sed Substitutions simples, suppression lignes
awk Traitement colonne, calculs, conditions
grep Recherche de motifs
tr Remplacement caractères
perl Regex complexes, Unicode

Règle générale : sed pour les transformations ligne par ligne simples, awk pour les traitements tabulaires, perl/Python pour les cas complexes.

Ressources

Regex testers en ligne

  • regex101.com : pratique pour prototyper, mais attention, ses moteurs (PCRE/ECMAScript) diffèrent des regex POSIX BRE/ERE de sed. Certaines syntaxes (\d, , lookarounds) n’existent pas en BRE/ERE. Validez toujours vos motifs directement avec sed.
  • regexr.com

Documentation

Conclusion

sed est un outil puissant pour éditer des fichiers texte en ligne de commande. Combiné avec les expressions régulières, il permet d’automatiser des tâches répétitives de transformation de texte.

Points clés à retenir :

  • s/pattern/replacement/g : substitution
  • -i : éditer en place (avec sauvegarde -i.bak)
  • -n + p : affichage sélectif
  • -E : regex étendues (plus lisibles)
  • Testez toujours sans -i avant de modifier

Pour des opérations plus complexes (parsing structuré, calculs, conditions multiples), préférez awk, jq (JSON), ou un langage de script.

Voir aussi

Recherche