VBA Replace dans Excel — Remplacer du texte & les pièges de ses arguments

Testé sur : Excel 365 v2509 · Excel 2021 · Excel 2019 · dernière vérification le 09/06/2026

En bref — Replace trouve une sous-chaîne et l'échange contre une autre — chaque occurrence, en une seule passe. C'est le Rechercher-Remplacer écrit en code, et il renvoie une nouvelle chaîne plutôt que de modifier l'originale :

Sub ReplaceDemo()
    Dim s As String
    s = "2026-04-01"
    Debug.Print Replace(s, "-", "/")     ' 2026/04/01   <- TOUS les tirets, un seul appel
    Debug.Print s                        ' 2026-04-01   <- l'original reste intact
End Sub

La signature complète, où se cache l'ennui :

Replace(expression, find, replace, [start], [count], [compare])
'                                    ⚠ pièges     vbTextCompare = ignore la casse

Le modèle mental : c'est Ctrl+H, pas « remplace le premier »

Quand vous appuyez sur Ctrl+H dans Excel et choisissez « Remplacer tout », il change chaque occurrence d'un coup. La fonction Replace de VBA fait exactement cela, par défaut — il n'y a pas de mode « trouver le suivant, demande-moi ». Donnez-lui une chaîne et elle renvoie une copie où chaque occurrence est échangée.

Deux choses découlent directement de ce modèle. D'abord, elle ne touche pas la variable d'origine — Replace est une fonction qui renvoie le résultat, vous devez donc le capturer (s = Replace(s, …)). Ensuite, comme elle change tout, Replace est le bon outil pour les transformations globales — normaliser tous les séparateurs, retirer tous les $, changer tous les "N/A" en "" — et le mauvais quand vous ne voulez changer qu'une occurrence précise. Nous y reviendrons, car la voie « ne changer que la première » est précisément là où les arguments de Replace deviennent un piège à perte de données.

La règle d'or : Replace est sensible à la casse par défaut

Voici la règle derrière la moitié des questions « mon Replace ne fait rien » sur internet :

Par défaut, Replace compare avec vbBinaryCompare — casse exacte. Replace("Hello", "h", "J") renvoie "Hello" inchangé, car un H majuscule n'est pas un h minuscule.

Pour faire correspondre sans tenir compte de la casse, vous devez passer le sixième argument explicitement :

Debug.Print Replace("Hello", "h", "J")                      ' Hello   (aucune correspondance !)
Debug.Print Replace("Hello", "h", "J", , , vbTextCompare)   ' Jello   (le H correspond)

Notez les deux virgules vides — vous sautez start et count pour atteindre compare. Cette gaucherie est un indice du langage : ces arguments du milieu, on a généralement intérêt à ne pas y toucher. Ce qui nous amène au vrai piège.

Le piège qui dévore vos données : start tronque le résultat

Tout le monde lit l'argument start comme « commencer à chercher à cette position ». Il le fait — et jette aussi tout ce qui précède. La chaîne que renvoie Replace commence à start :

Debug.Print Replace("ABCDEF", "C", "x", 3)
' Vous attendez : "ABxDEF"
' Vous obtenez :  "xDEF"        <- "AB" a DISPARU

Commencer à la position 3 signifie que la valeur renvoyée commence au 3e caractère ("CDEF"), remplacement appliqué → "xDEF". Les deux premiers caractères ne sont pas sautés puis conservés — ils sont entièrement retirés de la sortie. Sur un cas isolé, c'est évident ; enfoui dans une fonction qui traite 50 000 cellules, cela raccourcit en silence chaque valeur, et vous le découvrez quand les totaux ne tombent plus juste.

L'argument count (nombre maximal de remplacements) est moins destructeur, mais il interagit avec start exactement comme vous ne le voulez pas quand votre vrai but est « seulement le premier ». La règle honnête : laissez start et count à leurs valeurs par défaut. S'il vous faut vraiment ne remplacer que la première occurrence, ne recourez pas à count — localisez-la avec InStr et reconstruisez avec Mid :

' Remplacer seulement le PREMIER "-" sans perdre le préfixe
pos = InStr(s, "-")
If pos > 0 Then s = Left(s, pos - 1) & "/" & Mid(s, pos + 1)

Plus de code que Replace(s, "-", "/", , 1) — mais cela ne dévore pas le début de votre chaîne.

L'autre Replace : Range.Replace change la feuille, pas une chaîne

Il y a deux « Replace » complètement différents dans VBA Excel, et les confondre coûte des heures. La fonction (Replace(...)) transforme une chaîne en mémoire. La méthode (Range.Replace ...) est un Rechercher-Remplacer sur la feuille elle-même :

' Méthode — réécrit les cellules directement, colonne entière en un appel, sans boucle
Columns("B").Replace What:="N/A", Replacement:="", _
                     LookAt:=xlWhole, MatchCase:=False

Si votre but est « changer ce texte sur une plage de cellules », n'appelez pas la fonction de chaîne cellule par cellule dans une boucle. Range.Replace traite toute la plage d'un coup et est radicalement plus rapide sur les grandes feuilles. Réservez la fonction de chaîne au cas où vous manipulez une valeur que vous détenez déjà dans une variable.

L'avis : ces arguments optionnels sont des pièges, pas des fonctionnalités

Le Replace de VBA a six paramètres, et la conception vous souffle d'en utiliser trois. expression, find, replace — oui. compare — parfois, quand la casse compte. start et count — presque jamais, car leur comportement (tronquer le résultat, interaction maladroite) surprend tout le monde et corrompt les données en silence.

Ma règle empirique : si vous tapez le quatrième ou cinquième argument de Replace, arrêtez-vous et demandez-vous si vous vouliez en fait InStr + Mid. Neuf fois sur dix, vous vouliez « remplacer la première occurrence » ou « remplacer à partir d'ici », et la chirurgie par position est à la fois plus claire et sûre. L'appel à deux virgules sautées avec vbTextCompare est la seule forme « avancée » de Replace à garder en mémoire musculaire.

Quand utiliser quoi

Erreurs fréquentes avec Replace (et la solution)

Quand le nettoyage de texte devient le travail — décrivez le résultat

Un Replace est trivial. Un vrai nettoyage en est une pile — retirer le $, échanger les séparateurs de milliers, normaliser "N/A", corriger les tirets de date, rogner le reste — appliquée sur une feuille, dans le bon ordre, sans saccager des valeurs qui contiennent légitimement un signe dollar. ExcelMaster Agent vous laisse décrire l'état final — « nettoie la colonne C : retire les symboles monétaires, vide les N/A, uniformise le format de date » — et génère du Python qui le fait en sécurité et sauvegarde d'abord votre fichier, sans surprise de l'argument start. Essayez gratuitement →

Guides associés

• VBA Split — Découper une chaîne en tableau
• VBA Mid, Left & Right — Extraire une sous-chaîne par position
• VBA InStr — Trouver du texte dans une chaîne
• Boucle For en VBA — 8 exemples concrets

FAQ

Que fait Replace en VBA ? La fonction Replace renvoie une copie d'une chaîne où chaque occurrence d'une sous-chaîne est échangée contre une autre. Replace("a-b-c", "-", "/") renvoie "a/b/c". Elle ne modifie pas la variable d'origine — vous devez réaffecter le résultat.

Pourquoi mon VBA Replace ne fonctionne pas / ne remplace rien ? La cause la plus fréquente est la casse. Par défaut, Replace est sensible à la casse (vbBinaryCompare), donc Replace("Hello", "h", "J") ne trouve aucune correspondance. Passez vbTextCompare en sixième argument pour correspondre quelle que soit la casse. La deuxième cause la plus fréquente est l'oubli de capturer la valeur de retour.

Comment rendre VBA Replace insensible à la casse ? Ajoutez vbTextCompare comme argument compare : Replace(s, find, repl, , , vbTextCompare). Les deux virgules vides sautent les arguments start et count, que vous devriez normalement laisser à leurs valeurs par défaut.

Pourquoi VBA Replace coupe-t-il le début de ma chaîne ? Parce que vous avez passé l'argument start. Replace renvoie une chaîne qui commence à start — tout ce qui précède cette position est jeté, pas conservé. Pour remplacer dans une chaîne sans perdre le préfixe, omettez start ou utilisez InStr + Mid.

Quelle est la différence entre Replace et Range.Replace ? Replace(...) est une fonction qui transforme une chaîne en mémoire. Range.Replace ... est une méthode qui effectue un Rechercher-Remplacer directement sur les cellules de la feuille, sur toute une plage, en un seul appel. Utilisez la méthode pour modifier la feuille ; la fonction pour modifier une variable de chaîne.