6 min de lecture

Regex - 06 - Backreferences : réutiliser ce que tu as capture

Les backreferences regex avec backslash-1 pour matcher des repetitions et dollar-1 pour les remplacements puissants.

regex expressions regulieres backreferences
Regex 7 / 18
  1. 01 Regex - 00 - Les expressions regulieres, arme secrete ou piège mortel
  2. 02 Regex - 01 - Les bases : caractères litteraux et echappement
  3. 03 Regex - 02 - Quantificateurs : combien de fois tu veux matcher
  4. 04 Regex - 03 - Ancres : contrôler ou ta regex matche
  5. 05 Regex - 04 - Classes de caractères : définir tes propres ensembles
  6. 06 Regex - 05 - Groupes et alternation : structurer tes patterns
  7. 07 Regex - 06 - Backreferences : réutiliser ce que tu as capture
  8. 08 Regex - 07 - Les groupes nommes
  9. 09 Regex - 08 - Lookahead et lookbehind
  10. 10 Regex - 09 - Les flags
  11. 11 Regex - 10 - Les regex en JavaScript
  12. 12 Regex - 11 - Patterns courants
  13. 13 Regex - 12 - Les outils du quotidien
  14. 14 Regex - 13 - Unicode et regex
  15. 15 Regex - 14 - Performance et sécurité
  16. 16 Regex - 15 - Parsing du monde réel
  17. 17 Regex - 16 - Quand ne PAS utiliser les regex
  18. 18 Regex - 17 - Glossaire
← Precedent Suivant →

06 - Backreferences : réutiliser ce que tu as capture

Ce que tu vas apprendre

  • Les backreferences \1, \2 pour matcher le meme texte qu'un groupe
  • La détection de mots repetes
  • Les remplacements avec $1, $2
  • Des exemples pratiques : swap, reformatage, deduplication

Prerequisites

Maitriser les groupes capturants et comprendre la numerotation des captures.

Le problème : matcher "la meme chose qu'avant"

Tu veux trouver les mots repetes dans un texte, comme "le le" ou "est est". Ces doublons se glissent partout, surtout quand tu edites un texte en vitesse. Mais comment dire a une regex "matche un mot, puis matche exactement le meme mot" ?

Les classes et les quantificateurs ne suffisent pas. \w+ \w+ matche deux mots, mais pas forcement les memes. Il te faut un moyen de dire "le deuxieme mot doit etre identique au premier".

C'est exactement ce que font les backreferences.

`\1` : matcher le meme texte que le groupe 1

Une backreference \1 matche exactement le meme texte que ce qui a ete capture par le groupe 1. Pas le meme pattern, le meme texte.

\b(\w+)\s+\1\b

Decomposons :

  • \b : limite de mot
  • (\w+) : capture un mot (groupe 1)
  • \s+ : un ou plusieurs espaces
  • \1 : le meme texte que le groupe 1
  • \b : limite de mot

Teste avec :

le le chat dort
il est est parti
bonjour bonjour
hello world

Résultats :

  • "le le" matche (mot répété)
  • "est est" matche (mot répété)
  • "bonjour bonjour" matche (mot répété)
  • "hello world" ne matche pas (deux mots différents)

C'est elegant. Le groupe 1 capture "le", puis \1 vérifié que le mot suivant est aussi "le". Si le groupe avait capture "est", \1 chercherait "est".

J'utilise cette regex régulièrement pour relire mes articles. C'est fou le nombre de doublons qui echappent a la relecture humaine.

Backreferences multiples

Tu peux avoir plusieurs backreferences. \2 fait référencé au groupe 2, \3 au groupe 3, etc.

(\w+) (\w+) \2 \1

Matche un pattern "A B B A" :

Teste avec :

bon jour jour bon
hello world world hello
un deux trois quatre

Seuls "bon jour jour bon" et "hello world world hello" matchent. Le pattern impose une symetrie.

Ce n'est pas un cas d'usage quotidien, mais ca illustre bien le mecanisme. Les backreferences permettent d'exprimer des contraintes de répétition que les regex classiques ne peuvent pas capturer autrement.

Les remplacements avec `$1`, `$2`

L'autre usage majeur des groupes capturants, c'est le remplacement. Dans un search-and-replace, $1 fait référencé au contenu du groupe 1 dans le pattern de remplacement.

La syntaxe depend du contexte :

  • Dans le pattern de recherche : \1, \2 (backreferences)
  • Dans le pattern de remplacement : $1, $2 (substitutions)

Exemple 1 : reformater des dates

Tu as des dates au format "JJ/MM/AAAA" et tu veux le format ISO "AAAA-MM-JJ" :

Recherche :

(\d{2})/(\d{2})/(\d{4})

Remplacement :

$3-$2-$1
Avant Apres
28/03/2026 2026-03-28
15/12/2025 2025-12-15
01/01/2000 2000-01-01

C'est un classique. En trois secondes dans VS Code (Ctrl+H avec le mode regex active), tu reformates des centaines de dates.

Exemple 2 : inverser prenom et nom

Tu as une liste "Prenom Nom" et tu veux "Nom, Prenom" :

Recherche :

^(\w+) (\w+)$

Remplacement :

$2, $1
Avant Apres
Nicolas Nguyen Nguyen, Nicolas
Marie Dupont Dupont, Marie
Jean Martin Martin, Jean

Avec le flag m (multiline), ca fonctionne sur un fichier entier ligne par ligne.

Exemple 3 : transformer des imports

Tu migres d'un format d'import a un autre en JavaScript :

Recherche :

const (\w+) = require\("([^"]+)"\);

Remplacement :

import $1 from "$2";
Avant Apres
const express = require("express"); import express from "express";
const path = require("path"); import path from "path";

J'ai utilise cette regex sur un projet de migration CommonJS vers ESM. Quarante fichiers, deux cents imports. Dix minutes au lieu d'une apres-midi. Sur paltemps.fr, ce genre de refactoring regex nous a fait gagner des heures.

Exemple 4 : détecter les doublons dans des donnees

Au-dela des mots repetes, tu peux détecter des lignes dupliquees dans un CSV. Si tu tries ton fichier d'abord, les doublons sont adjacents et tu peux les trouver avec :

^(.+)\n\1$

Avec le flag m, cette regex trouve les lignes consecutives identiques.

Backreferences en JavaScript

En code, les backreferences s'utilisent avec replace() :

javascript// Reformater une date
const date = "28/03/2026";
const iso = date.replace(/(\d{2})\/(\d{2})\/(\d{4})/, "$3-$2-$1");
// "2026-03-28"

// Supprimer les mots doubles
const text = "le le chat est est parti";
const clean = text.replace(/\b(\w+)\s+\1\b/g, "$1");
// "le chat est parti"

Note le flag g (global) pour remplacer toutes les occurrences, pas juste la première.

Backreferences en Python

pythonimport re

# Reformater une date
date = "28/03/2026"
iso = re.sub(r"(\d{2})/(\d{2})/(\d{4})", r"\3-\2-\1", date)
# "2026-03-28"

# Supprimer les mots doubles
text = "le le chat est est parti"
clean = re.sub(r"\b(\w+)\s+\1\b", r"\1", text)
# "le chat est parti"

En Python, la syntaxe de remplacement utilise \1 au lieu de $1. C'est une des différences entre les flavours de regex.

Limites des backreferences

Les backreferences ont des limites. Elles ne fonctionnent que dans la meme regex ou le meme remplacement. Tu ne peux pas faire de backreference entre deux appels de regex separes.

Elles peuvent aussi poser des problèmes de performance sur de tres gros textes. Le moteur de regex doit se souvenir de chaque capture et les comparer. Sur des fichiers de plusieurs megaoctets, ca peut devenir lent.

Et il y a la limite du nombre de groupes. La plupart des moteurs supportent 9 backreferences (\1 a \9). Au-dela, certains moteurs supportent \10 et plus, d'autres non. Si tu en arrives la, ta regex est probablement trop complexe et tu devrais envisager un vrai parser.

Astuce : le remplacement vide pour supprimer

Tu peux utiliser un remplacement vide pour supprimer des patterns :

Recherche :

\s*//.*$

Remplacement : (vide)

Ca supprime tous les commentaires en fin de ligne. Brutal mais efficace pour du nettoyage ponctuel.

Résumé

  • \1, \2 dans le pattern de recherche matchent le meme texte que le groupe correspondant
  • $1, $2 dans le remplacement inserent le contenu des captures
  • La détection de mots repetes utilise \b(\w+)\s+\1\b
  • Le reformatage de dates, l'inversion de champs et la migration d'imports sont des cas d'usage courants
  • Python utilise \1 dans les remplacements, JavaScript utilise $1
  • Au-dela de 9 groupes, repense ta stratégie
Article précédent 05 - Groupes
Article suivant 07 - Named groups

Sources

Publie le · Mis a jour le

Articles liés

Réservez un audit gratuit de 30 minutes. Je vous montre concrètement ce qu'on peut automatiser.

Découvrir Pal'Temps