En dehors des classes de caractères, un antislash suivi d'un nombre plus grand que 0 (et possiblement plusieurs chiffres) est une référence arrière (c'est-à-dire vers la gauche) dans le masque, en supposant qu'il y ait suffisamment de sous-masques capturants précédents.
Cependant, si le nombre décimal suivant l'antislash est plus petit que 10, il sera toujours considéré comme une référence arrière, et cela générera une erreur si le nombre de captures n'est pas suffisant. En d'autres termes, il faut qu'il existe suffisamment de parenthèses ouvrantes à gauche de la référence, surtout si la référence est inférieure à 10. Une "référence arrière vers l'avant" peut avoir du sens lorsqu'une répétition est isolée et que le sous masque à droite a participé à l'itération précédente. Voir la section sur les séquences d'échappements pour plus de détails à propos du nombre de chiffres qui suivent l'antislash.
La référence arrière remplace ce qui a
été capturé par un sous-masque dans le
masque courant, plutôt que remplacer le sous-masque
lui-même. Ainsi
(calme|rapide) et \1ment
trouvera "calme et calmement"
et "rapide et rapidement", mais pas
"calme et rapidement". Si la recherche tient
compte de la casse, alors la casse de la chaîne
capturée sera importante. Par exemple,
((?i)rah)\s+\1
trouve "rah rah"
et "RAH RAH", mais pas "RAH rah",
même si le sous-masque capturant initial ne tenait pas compte
de la casse.
Il peut y avoir plusieurs références arrière dans
le même sous-masque. Si un sous-masque n'a pas été
utilisé dans une recherche, alors les références
arrière échoueront. Par exemple
(a|(bc))\2
ne réussira jamais si la chaîne sujet commence par
"a" plutôt que par "bc".
Étant donné qu'il peut y avoir jusqu'à 99 références
arrière, tous les chiffres après l'antislash sont
considérés comment faisant potentiellement partie de
la référence arrière. Si le masque recherche un
chiffre après la référence, alors il faut
impérativement utiliser des délimiteurs pour terminer
la référence arrière.
Si l'option PCRE_EXTENDED
est activée, on peut utiliser un espace.
Sinon, un commentaire vide fait l'affaire.
Une référence arrière qui intervient à l'intérieur de
parenthèses auxquelles elle fait référence
échouera dès que le sous-masque sera utilisé. Par exemple,
(a\1)
échouera toujours. Cependant, ces
références peuvent être utiles dans les
sous-masques répétitifs. Par exemple, le masque
"(a|b\1)+" pourra convenir pour "a",
"aba", "ababba", etc.
À chaque itération du sous-masque, la référence
arrière utilise le résultat du dernier sous-masque.
Pour que cela fonctionne, il faut que la première
itération n'ait pas besoin d'utiliser la référence
arrière. Cela arrive avec les alternatives, comme dans
l'exemple ci-dessus, ou avec un quantificateur de minimum 0.
La séquence d'échappement \g
peut être utilisée pour le référencement absolu et relatif des
sous-masques. Cette séquence doit être suivie par un nombre non signé
ou négatif, entouré optionnellement par des accolades. La séquence
\1, \g1 et \g{1}
sont identiques. L'utilisation de ce masque avec un nombre non signé peut
aider à ne pas le confondre lors de l'utilisation de nombre suivi d'un
antislash. Cette séquence aide à distinguer les références arrière
lors de l'utilisation de caractères octales et rend également plus facile
d'avoir une référence arrière suivie par un nombre litéral, i.e.
\g{2}1.
L'utilisation de la séquence \g avec un nombre négatif
indique une référence relative. Par exemple, (foo)(bar)\g{-1}
trouvera la séquence "foobarbar" et (foo)(bar)\g{-2} trouvera
la séquence "foobarfoo". Ceci peut être pratique dans ce gros masque
comme alternative afin de conserver une trace du nombre de sous-masques
afin de référencer un sous-masque précédant spécifique.
Les références arrière du sous-masque nommé peuvent être
utilisées sous la forme
(?P=name),
\k<name>, \k'name',
\k{name}, \g{name},
\g<name> ou \g'name'.
Something similar opportunity is DEFINE.
Example:
(?(DEFINE)(?<myname>\bvery\b))(?&myname)\p{Pd}(?&myname).
Expression above will match "very-very" from next sentence:
Define is very-very handy sometimes.
^-------^
How it works. (?(DEFINE)(?<myname>\bvery\b)) - this block defines "myname" equal to "\bvery\b". So, this block "(?&myname)\p{Pd}(?&myname)" equvivalent to "\bvery\b\p{Pd}\bvery\b".The escape sequence \g used as a backreference may not always behave as expected.
The following numbered backreferences refer to the text matching the specified capture group, as documented:
\1
\g1
\g{1}
\g-1
\g{-1}
However, the following variants refer to the subpattern code instead of the matched text:
\g<1>
\g'1'
\g<-1>
\g'-1'
With named backreferences, we may also use the \k escape sequence as well as the (?P=...) construct. The following combinations also refer to the text matching the named capture group, as documented:
\g{name}
\k{name}
\k<name>
\k'name'
(?P=name)
However, these refer to the subpattern code instead of the matched text:
g<name>
\g'name'
In the following example, the capture group searches for a single letter 'a' or 'b', and then the backreference looks for the same letter. Thus, the patterns are expected to match 'aa' and 'bb', but not 'ab' nor 'ba'.
<?php
/* Matches to the following patterns are replaced by 'xx' in the subject string 'aa ab ba bb'. */
$patterns = [
# numbered backreferences (absolute)
'/([ab])\1/', // 'xx ab ba xx'
'/([ab])\g1/', // 'xx ab ba xx'
'/([ab])\g{1}/', // 'xx ab ba xx'
'/([ab])\g<1>/', // 'xx xx xx xx' # unexpected behavior, backreference matches both 'a' and 'b'.
"/([ab])\g'1'/", // 'xx xx xx xx' # unexpected behavior, backreference matches both 'a' and 'b'.
'/([ab])\k{1}/', // 'aa ab ba bb' # No group with name "1", backreference to unset group always fails.
'/([ab])\k<1>/', // 'aa ab ba bb' # No group with name "1", backreference to unset group always fails.
"/([ab])\k'1'/", // 'aa ab ba bb' # No group with name "1", backreference to unset group always fails.
'/([ab])(?P=1)/', // NULL # Regex error: "subpattern name must start with a non-digit", (?P=) expects name not number.
# numbered backreferences (relative)
'/([ab])\-1/', // 'aa ab ba bb'
'/([ab])\g-1/', // 'xx ab ba xx'
'/([ab])\g{-1}/', // 'xx ab ba xx'
'/([ab])\g<-1>/', // 'xx xx xx xx' # unexpected behavior, backreference matches both 'a' and 'b'.
"/([ab])\g'-1'/", // 'xx xx xx xx' # unexpected behavior, backreference matches both 'a' and 'b'.
'/([ab])\k{-1}/', // 'aa ab ba bb' # No group with name "-1", backreference to unset group always fails.
'/([ab])\k<-1>/', // 'aa ab ba bb' # No group with name "-1", backreference to unset group always fails.
"/([ab])\k'-1'/", // 'aa ab ba bb' # No group with name "-1", backreference to unset group always fails.
'/([ab])(?P=-1)/', // NULL # Regex error: "subpattern name expected", (?P=) expects name not number.
# named backreferences
'/(?<name>[ab])\g{name}/', // 'xx ab ba xx'
'/(?<name>[ab])\g<name>/', // 'xx xx xx xx' # unexpected behavior, backreference matches both 'a' and 'b'.
"/(?<name>[ab])\g'name'/", // 'xx xx xx xx' # unexpected behavior, backreference matches both 'a' and 'b'.
'/(?<name>[ab])\k{name}/', // 'xx ab ba xx'
'/(?<name>[ab])\k<name>/', // 'xx ab ba xx'
"/(?<name>[ab])\k'name'/", // 'xx ab ba xx'
'/(?<name>[ab])(?P=name)/', // 'xx ab ba xx'
];
foreach ($patterns as $pat)
echo " '$pat',\t// " . var_export(@preg_replace($pat, 'xx', 'aa ab ba bb'), 1) . PHP_EOL;
?>