Regular Expressions
Substitutions avec des expressions régulières

Paramètres

Bases de la substitution

L'une des méthodes les plus courantes et les plus utiles pour remplacer le texte par regex consiste à utiliser des groupes de capture .
Ou même un groupe de capture nommé , comme référence pour stocker ou remplacer les données.

Il y a deux termes très similaires dans les documents de regex, il peut donc être important de ne jamais mélanger les substitutions (c'est- $1 dire $1 ) avec les backreferences (c.-à-d. \1 ). Les termes de substitution sont utilisés dans un texte de remplacement; Backreferences, dans l'expression pure Regex. Même si certains langages de programmation acceptent les deux pour les substitutions, ce n'est pas encourageant.

Disons que nous avons cette regex: /hello(\s+)world/i . Chaque fois que $number est référencé (dans ce cas, $1 ), les espaces blancs correspondant à \s+ seront remplacés à la place.
Le même résultat sera exposé avec le regex: /hello(?<spaces>\s+)world/i . Et comme nous avons un groupe nommé ici, nous pouvons également utiliser ${spaces} .

Dans ce même exemple, nous pouvons également utiliser $0 ou $& ( Remarque: $& peut être utilisé comme $+ place, ce qui signifie récupérer le groupe de capture LAST dans d’autres moteurs regex), en fonction du type de regex avec lequel vous travaillez, pour obtenir le texte entier correspondant. (c.- $& d. $& renverra hEllo woRld pour la chaîne: hEllo woRld of Regex! )

---

Jetez un coup d'oeil à cet exemple simple de substitution en utilisant le devis adapté de John Lennon en utilisant la syntaxe $number et la syntaxe ${name} :

Exemple de groupe de capture simple:

Exemple de groupe de capture nommé:

Remplacement Avancé

Certains langages de programmation ont leurs propres particularités Regex, par exemple le terme $+ (en C #, Perl, VB etc.) qui remplace le texte correspondant au dernier groupe capturé.

Exemple:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)\s\1\b";
      string substitution = "$+";
      string input = "The the dog jumped over the fence fence.";
      Console.WriteLine(Regex.Replace(input, pattern, substitution, 
                        RegexOptions.IgnoreCase));
   }
}
// The example displays the following output:
//      The dog jumped over the fence.

_{Exemple du réseau de développeurs de Microsoft Official ^[1]}

---

Les autres termes de substitution rares sont $` et $' :

$` = Remplace les correspondances au texte avant la chaîne correspondante
$' = Remplace les correspondances au texte après la chaîne correspondante

De ce fait, ces chaînes de remplacement devraient faire leur travail comme ceci:

Regex: /part2/
Input: "part1part2part3"
Replacement: "$`"
Output: "part1part1part3" //Note that part2 was replaced with part1, due &` term
---------------------------------------------------------------------------------
Regex: /part2/
Input: "part1part2part3"
Replacement: "$'"
Output: "part1part3part3" //Note that part2 was replaced with part3, due &' term

Voici un exemple de ces substitutions travaillant sur un morceau de javascript:

var rgx = /middle/;
var text = "Your story must have a beginning, middle, and end"
console.log(text.replace(rgx, "$`")); 
//Logs: "Your story must have a beginning, Your story must have a beginning, , and end"
console.log(text.replace(rgx, "$'"))
//Logs: "Your story must have a beginning, , and end, and end"

---

Il y a aussi le terme $_ qui récupère tout le texte correspondant à la place:

Regex: /part2/
Input: "part1part2part3"
Replacement: "$_"
Output: "part1part1part2part3part3" //Note that part2 was replaced with part1part2part3,
                                                                         // due $_ term

Convertir ceci en VB nous donnerait ceci:

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ABC123DEF456"
      Dim pattern As String = "\d+"
      Dim substitution As String = "$_"
      Console.WriteLine("Original string:          {0}", input)
      Console.WriteLine("String with substitution: {0}", _
                        Regex.Replace(input, pattern, substitution))      
   End Sub
End Module
' The example displays the following output:
'       Original string:          ABC123DEF456
'       String with substitution: ABCABC123DEF456DEFABC123DEF456

_{Exemple du réseau de développeurs de Microsoft Official ^[2]}

---

Et le dernier terme de substitution, mais non le moindre, est $$ , qui traduit en une expression rationnelle serait le même que \$ (version échappée du littéral $ ).

Si vous voulez faire correspondre une chaîne comme ceci: USD: $3.99 par exemple, et que vous voulez stocker le 3.99 , mais le remplacer par $3.99 avec une seule regex, vous pouvez utiliser:

Regex: /USD:\s+\$([\d.]+)/
Input: "USD: $3.99"
Replacement: "$$$1"
To Store: "$1"
Output: "$3.99"
Stored: "3.99"

Si vous souhaitez tester cela avec Javascript, vous pouvez utiliser le code:

var rgx = /USD:\s+\$([\d.]+)/;
var text = "USD: $3.99";
var stored = parseFloat(rgx.exec(text)[1]);
console.log(stored); //Logs 3.99
console.log(text.replace(rgx, "$$$1")); //Logs $3.99

---

Les références

[1]: substituer le dernier groupe capturé
[2]: substituer la chaîne de saisie entière