Rechercher et remplacer dans un fichier

Un port à changer dans une configuration Nginx, une adresse IP à mettre à jour dans dix fichiers, un nom d’hôte à corriger après un renommage de serveur — ces opérations reviennent constamment en administration Linux. Savoir les faire vite, sans erreur et sans ouvrir un éditeur graphique, fait partie des compétences de base d’un administrateur.

Ce guide couvre les trois approches principales : le remplacement non-interactif avec sed (le plus courant en administration), le remplacement interactif dans un éditeur (nano, vi, vim), et le remplacement multi-fichiers en combinant find et sed.

Ce que vous allez apprendre

• Remplacer un mot ou un motif dans un fichier avec sed
• Vérifier un remplacement avant de l’appliquer
• Rechercher et remplacer dans nano, vi et vim
• Appliquer un remplacement sur plusieurs fichiers à la fois
• Choisir le bon outil selon la situation

Quel outil pour quelle situation ?

Avant de détailler chaque méthode, voici la règle de décision rapide :

Situation	Outil recommandé	Pourquoi
Remplacement rapide dans un fichier de config	sed	Une seule commande, pas d’éditeur à ouvrir
Remplacement dans un script ou un pipeline	sed	Non-interactif, scriptable
Remplacement avec vérification visuelle ligne par ligne	vim (:s/.../gc)	Confirmation avant chaque remplacement
Édition ponctuelle d’un fichier simple	nano	Le plus accessible pour un débutant
Remplacement massif dans 10+ fichiers	find + sed	Automatisé, pas d’intervention manuelle
Fichier volumineux avec contexte à comprendre	vim ou vi	Navigation et recherche intégrées

Glissez pour voir

Remplacement non-interactif avec sed

sed (stream editor) est l’outil de référence pour modifier du texte en ligne de commande. Il lit un fichier ligne par ligne, applique une transformation et écrit le résultat. Vous ne quittez jamais votre terminal.

Syntaxe de base

sed 's/ancien/nouveau/' fichier

Cette commande remplace la première occurrence de ancien par nouveau sur chaque ligne, et affiche le résultat sur la sortie standard. Le fichier original n’est pas modifié.

Pour remplacer toutes les occurrences sur chaque ligne, ajoutez le drapeau g (global) :

sed 's/ancien/nouveau/g' fichier

Vérifier avant de modifier

La bonne pratique consiste à toujours vérifier le résultat avant de toucher au fichier. sed affiche le résultat par défaut sans modifier le fichier — profitez-en.

1. Voir ce qui va changer :

   sed 's/8080/8443/g' /etc/nginx/sites-available/default

   Le fichier entier s’affiche avec les remplacements appliqués. Comparez visuellement.

2. Cibler les lignes concernées :

   grep -n '8080' /etc/nginx/sites-available/default

   Vous voyez les numéros de lignes contenant le motif — utile pour vérifier qu’il n’y a pas de remplacement indésirable.

3. Appliquer la modification :

   sed -i 's/8080/8443/g' /etc/nginx/sites-available/default

   L’option -i (in-place) modifie le fichier directement.

Toujours vérifier avant -i

L’option -i modifie le fichier sans possibilité d’annulation. Sur un fichier de configuration critique, créez une copie de sauvegarde avant :

cp /etc/nginx/sites-available/default /etc/nginx/sites-available/default.bak
sed -i 's/8080/8443/g' /etc/nginx/sites-available/default

Ou utilisez sed -i.bak qui crée automatiquement une copie avec l’extension .bak :

sed -i.bak 's/8080/8443/g' /etc/nginx/sites-available/default

Exemples concrets d’administration

Changer un port :

sed -i 's/Listen 80/Listen 443/g' /etc/apache2/ports.conf

Remplacer une adresse IP :

sed -i 's/192.168.1.10/192.168.1.20/g' /etc/hosts

Modifier un paramètre de configuration :

sed -i 's/^#PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config

Cette dernière commande décommente et modifie la ligne en une seule opération. Le ^# signifie “commence par #” et .* correspond au reste de la ligne.

Délimiteur alternatif

Quand le texte contient des / (chemins de fichiers par exemple), utilisez un autre délimiteur pour éviter les échappements illisibles :

# Difficile à lire
sed -i 's/\/usr\/local\/bin/\/opt\/bin/g' script.sh

# Lisible — utilisez | ou # comme délimiteur
sed -i 's|/usr/local/bin|/opt/bin|g' script.sh

Restreindre à certaines lignes

Vous pouvez limiter le remplacement à une plage de lignes ou à un motif :

# Lignes 10 à 20 seulement
sed -i '10,20s/ancien/nouveau/g' fichier.conf

# Uniquement les lignes contenant "server"
sed -i '/server/s/8080/8443/g' nginx.conf

Rechercher et remplacer dans un éditeur

Nano

Dans nano, le raccourci Ctrl+\ lance la fonction rechercher/remplacer :

1. Ouvrez le fichier :

   nano /etc/hosts

2. Appuyez sur Ctrl+\

3. Tapez le texte à chercher, puis Entrée

4. Tapez le texte de remplacement, puis Entrée

5. Pour chaque occurrence, nano vous demande : Y (remplacer), N (ignorer), A (tout remplacer)

Quand utiliser nano : fichier simple, modification ponctuelle, vous voulez voir ce que vous faites à chaque étape. Détails complets dans le guide Nano.

Vi / Vim

Dans vi ou vim, le remplacement se fait depuis le mode commande :

:%s/ancien/nouveau/g      # Tout le fichier, toutes les occurrences
:%s/ancien/nouveau/gc     # Avec confirmation pour chaque occurrence
:10,20s/ancien/nouveau/g  # Lignes 10 à 20 seulement

Le % signifie “tout le fichier”. Le drapeau c (confirm) vous montre chaque occurrence et attend votre réponse :

• y — remplacer
• n — ignorer
• a — tout remplacer (sans plus demander)
• q — arrêter

Pour chercher sans remplacer, tapez /motif en mode normal, puis n pour l’occurrence suivante.

Quand utiliser vim : fichier complexe, besoin de contexte visuel, remplacement sélectif avec confirmation. Détails complets dans le guide Vi et le guide Vim.

Remplacement dans plusieurs fichiers

find + sed

Pour appliquer un remplacement dans tous les fichiers d’un répertoire :

find /etc/nginx/ -name '*.conf' -exec sed -i 's/8080/8443/g' {} +

Cette commande :

1. trouve tous les fichiers .conf dans /etc/nginx/
2. applique le remplacement sed sur chacun

Vérifier avant de modifier en masse

Avant d’utiliser -i, listez d’abord les fichiers concernés et prévisualisez :

# Quels fichiers sont touchés ?
grep -rl '8080' /etc/nginx/

# Voir les lignes qui vont changer
grep -rn '8080' /etc/nginx/

grep + sed en pipeline

Variante qui cible uniquement les fichiers contenant le motif :

grep -rl 'ancien-hostname' /etc/ | xargs sed -i 's/ancien-hostname/nouveau-hostname/g'

grep -rl liste les fichiers contenant le motif (récursivement, noms uniquement), et xargs passe chaque fichier à sed.

Exercice pratique

1. Créez un fichier de test :

   cat > /tmp/test-config.conf << 'EOF'
   server {
       listen 8080;
       server_name old-server.example.com;
       root /var/www/old-server;
   }
   EOF

2. Vérifiez le contenu :

   cat /tmp/test-config.conf

3. Remplacez le port avec sed (sans modifier le fichier) :

   sed 's/8080/443/' /tmp/test-config.conf

   Vérifiez que la ligne listen affiche bien 443.

4. Remplacez le nom d’hôte (en modifiant le fichier) :

   sed -i 's/old-server/new-server/g' /tmp/test-config.conf
   cat /tmp/test-config.conf

   Les deux occurrences de old-server doivent avoir été remplacées.

5. Ouvrez dans vim et remplacez avec confirmation :

   vim /tmp/test-config.conf

   Tapez :%s/new-server/prod-server/gc puis validez chaque occurrence avec y.

Dépannage

Symptôme	Cause probable	Solution
sed ne remplace rien	Le motif ne correspond pas exactement (casse, espaces)	Vérifier avec grep d’abord, utiliser -i pour ignorer la casse dans grep
Remplacement partiel (première occurrence seulement)	Drapeau g manquant	Utiliser s/ancien/nouveau/g
sed: -e expression #1, char X: unknown option to 's'	Le texte contient le délimiteur /	Utiliser un délimiteur alternatif : s|ancien|nouveau|g
Fichier modifié par erreur avec -i	Pas de sauvegarde préalable	Restaurer depuis .bak si sed -i.bak a été utilisé, sinon depuis un backup système
Permission denied sur un fichier dans /etc/	Droits insuffisants	Utiliser sudo sed -i ...
Remplacement dans vim n’atteint pas toutes les lignes	Portée limitée (:s sans %)	Utiliser :%s/ancien/nouveau/g pour tout le fichier
Caractères spéciaux dans le motif (., *, [)	Interprétés comme des expressions régulières	Échapper avec \ : sed 's/192\.168\.1\.10/192.168.1.20/g'

Glissez pour voir

À retenir

• sed -i 's/ancien/nouveau/g' fichier est la commande de remplacement la plus utilisée en administration Linux.
• Toujours vérifier avant d’utiliser -i : lancez sed sans -i ou utilisez grep -n pour voir les lignes concernées.
• sed -i.bak crée automatiquement une copie de sauvegarde — à privilégier sur les fichiers critiques.
• Nano (Ctrl+\) pour les remplacements ponctuels visuels.
• Vim (:%s/.../gc) pour les remplacements avec confirmation ligne par ligne.
• find + sed ou grep -rl + xargs sed pour le remplacement en masse dans plusieurs fichiers.
• Les points (.) dans les adresses IP sont des caractères spéciaux regex — échappez-les avec \.

Prochaines étapes

Filtrer et transformer du texte Utiliser grep, cut, sort et awk pour extraire et manipuler des données textuelles.

Administrer avec Vim Maîtriser le langage Vim : opérateurs, motions, macros et plugins.

Éditer avec Nano L'éditeur le plus accessible pour modifier rapidement un fichier.

Écrire des scripts robustes Automatiser ces remplacements dans des scripts fiables et maintenables.

×

📖 Voir la documentation →