Substitutions dans les expressions régulières

Les substitutions sont des éléments de langage reconnus uniquement dans des modèles de remplacement. Elles utilisent un modèle d'expression régulière pour définir tout ou partie du texte qui doit remplacer le texte correspondant dans la chaîne d'entrée. Le modèle de remplacement peut se composer d'une ou plusieurs substitutions avec des caractères littéraux. Les modèles de remplacement sont fournis aux surcharges de la méthode Regex.Replace qui a un paramètre replacement et à la méthode Match.Result . Les méthodes remplacent le modèle correspondant par le modèle défini par le paramètre replacement .

.NET définit les éléments de substitution répertoriés dans le tableau suivant.

Éléments de substitution et modèles de remplacement

Les substitutions sont les seules constructions particulières acceptées dans un modèle de remplacement. Aucun des autres éléments de langage d'expression régulière, notamment les caractères d'échappement et le point (.), qui correspond à n'importe quel caractère, n'est pris en charge. De la même façon, les éléments de langage de substitution sont reconnus uniquement dans les modèles de remplacement et ne sont jamais valides dans les modèles d'expressions régulières.

Le seul caractère qui peut apparaître dans un modèle d'expression régulière ou dans une substitution est le caractère $ , bien qu'il ait une signification différente dans chaque contexte. Dans un modèle d'expression régulière, $ est une ancre qui correspond à la fin de la chaîne. Dans un modèle de remplacement, $ indique le début d'une substitution.

Substitution d'un groupe numéroté

L'élément de langage $nombre inclut la dernière sous-chaîne correspondant au groupe de capture nombre dans la chaîne de remplacement, où nombre est l'index du groupe de capture. Par exemple, le modèle de remplacement $1 indique que la sous-chaîne correspondante sera remplacée par le premier groupe capturé. Pour plus d’informations sur les groupes de capture numérotés, consultez Grouping Constructs.

Tous les chiffres qui suivent $ sont interprétés comme appartenant au groupe nombre . Si ce n'est pas votre intention, vous pouvez remplacer un groupe nommé à la place. Par exemple, vous pouvez utiliser la chaîne de remplacement ${1}1 au lieu de $11 pour définir la chaîne de remplacement comme la valeur du premier groupe capturé avec le numéro « 1 ». Pour plus d'informations, consultez Substitution d'un groupe nommé.

Les groupes de capture auxquels des noms ne sont pas explicitement assignés à l'aide de la syntaxe (?<nom>) sont numérotés de gauche à droite en commençant à un. Les groupes nommés sont également numérotés de gauche à droite, en démarrant à un numéro de plus que l'index du dernier groupe sans nom. Par exemple, dans l'expression régulière (\w)(?<digit>\d), l'index du groupe nommé digit est 2.

Si le nombre ne spécifie pas un groupe de capture valide défini dans le modèle d'expression régulière, $nombre est interprété comme une séquence de caractères littéraux utilisée pour remplacer chaque correspondance.

L'exemple suivant utilise la substitution $nombre pour supprimer le symbole monétaire d'une valeur décimale. Elle supprime les symboles monétaires trouvés au début ou à la fin d'une valeur monétaire, et reconnaît les deux séparateurs décimaux les plus courants (« . » et « , »).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*";
      string replacement = "$1";
      string input = "$16.32 12.19 £16.29 €18.29  €18,29";
      string result = Regex.Replace(input, pattern, replacement);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//       16.32 12.19 16.29 18.29  18,29

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}*"
        Dim replacement As String = "$1"
        Dim input As String = "$16.32 12.19 £16.29 €18.29  €18,29"
        Dim result As String = Regex.Replace(input, pattern, replacement)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'       16.32 12.19 16.29 18.29  18,29

Le modèle d'expression régulière \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* est défini comme indiqué dans le tableau suivant.

Substitution d'un groupe nommé

L'élément de langage ${nom} substitue la dernière sous-chaîne correspondante au groupe de capture nom , où nom est le nom d'un groupe de capture défini par l'élément de langage (?<nom>) . Pour plus d’informations sur les groupes de capture nommés, consultez Grouping Constructs.

Si le nom ne spécifie pas de groupe de capture nommé valide défini dans le modèle d'expression régulière mais se compose de chiffres, ${nom} est interprété en tant que groupe numéroté.

Si le nom ne spécifie ni un groupe de capture nommé valide ni un groupe de capture numéroté valide défini dans le modèle d'expression régulière, ${nom} est interprété comme une séquence de caractères littéraux utilisée pour remplacer chaque correspondance.

L'exemple suivant utilise la substitution ${nom} pour supprimer le symbole monétaire d'une valeur décimale. Elle supprime les symboles monétaires trouvés au début ou à la fin d'une valeur monétaire, et reconnaît les deux séparateurs décimaux les plus courants (« . » et « , »).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*";
      string replacement = "${amount}";
      string input = "$16.32 12.19 £16.29 €18.29  €18,29";
      string result = Regex.Replace(input, pattern, replacement);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//       16.32 12.19 16.29 18.29  18,29

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\p{Sc}*(?<amount>\s?\d+[.,]?\d*)\p{Sc}*"
        Dim replacement As String = "${amount}"
        Dim input As String = "$16.32 12.19 £16.29 €18.29  €18,29"
        Dim result As String = Regex.Replace(input, pattern, replacement)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'       16.32 12.19 16.29 18.29  18,29

Le modèle d'expression régulière \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* est défini comme indiqué dans le tableau suivant.

Substitution d'un caractère « $ »

La substitution $$ insère un caractère « $ » littéral dans la chaîne remplacée.

L'exemple suivant utilise l'objet NumberFormatInfo pour déterminer le symbole monétaire de la culture actuelle et son positionnement dans une chaîne monétaire. Il génère alors à la fois dynamiquement un modèle d'expression régulière et un modèle de remplacement. Si l'exemple est exécuté sur un ordinateur dont la culture actuelle est en-US, il génère le modèle d'expression régulière \b(\d+)(\.(\d+))? et le modèle de remplacement $$ $1$2. Le modèle de remplacement remplace le texte correspondant par un symbole monétaire et un espace suivi par les premier et second groupes capturés.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Define array of decimal values.
      string[] values= { "16.35", "19.72", "1234", "0.99"};
      // Determine whether currency precedes (True) or follows (False) number.
      bool precedes = NumberFormatInfo.CurrentInfo.CurrencyPositivePattern % 2 == 0;
      // Get decimal separator.
      string cSeparator = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator;
      // Get currency symbol.
      string symbol = NumberFormatInfo.CurrentInfo.CurrencySymbol;
      // If symbol is a "$", add an extra "$".
      if (symbol == "$") symbol = "$$";

      // Define regular expression pattern and replacement string.
      string pattern = @"\b(\d+)(" + cSeparator + @"(\d+))?";
      string replacement = "$1$2";
      replacement = precedes ? symbol + " " + replacement : replacement + " " + symbol;
      foreach (string value in values)
         Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement));
   }
}
// The example displays the following output:
//       16.35 --> $ 16.35
//       19.72 --> $ 19.72
//       1234 --> $ 1234
//       0.99 --> $ 0.99

Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        ' Define array of decimal values.
        Dim values() As String = {"16.35", "19.72", "1234", "0.99"}
        ' Determine whether currency precedes (True) or follows (False) number.
        Dim precedes As Boolean = (NumberFormatInfo.CurrentInfo.CurrencyPositivePattern Mod 2 = 0)
        ' Get decimal separator.
        Dim cSeparator As String = NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator
        ' Get currency symbol.
        Dim symbol As String = NumberFormatInfo.CurrentInfo.CurrencySymbol
        ' If symbol is a "$", add an extra "$".
        If symbol = "$" Then symbol = "$$"

        ' Define regular expression pattern and replacement string.
        Dim pattern As String = "\b(\d+)(" + cSeparator + "(\d+))?"
        Dim replacement As String = "$1$2"
        replacement = If(precedes, symbol + " " + replacement, replacement + " " + symbol)
        For Each value In values
            Console.WriteLine("{0} --> {1}", value, Regex.Replace(value, pattern, replacement))
        Next
    End Sub
End Module
' The example displays the following output:
'       16.35 --> $ 16.35
'       19.72 --> $ 19.72
'       1234 --> $ 1234
'       0.99 --> $ 0.99

Le modèle d'expression régulière \b(\d+)(\.(\d+))? est défini comme indiqué dans le tableau suivant.

Substitution de la correspondance entière

La substitution $& inclut la correspondance entière dans la chaîne de remplacement. Souvent, elle est utilisée pour ajouter une sous-chaîne au début ou à la fin de la chaîne correspondante. Par exemple, le modèle de remplacement ($&) ajoute des parenthèses au début et à la fin de chaque correspondance. S'il n'y a pas de correspondance, la substitution $& n'a aucun effet.

L'exemple suivant utilise la substitution $& pour ajouter des guillemets au début et à la fin de titres de livres stockés dans un tableau de chaînes.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\w+\s?)+$";
      string[] titles = { "A Tale of Two Cities",
                          "The Hound of the Baskervilles",
                          "The Protestant Ethic and the Spirit of Capitalism",
                          "The Origin of Species" };
      string replacement = "\"$&\"";
      foreach (string title in titles)
         Console.WriteLine(Regex.Replace(title, pattern, replacement));
   }
}
// The example displays the following output:
//       "A Tale of Two Cities"
//       "The Hound of the Baskervilles"
//       "The Protestant Ethic and the Spirit of Capitalism"
//       "The Origin of Species"

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\w+\s?)+$"
        Dim titles() As String = {"A Tale of Two Cities", _
                                   "The Hound of the Baskervilles", _
                                   "The Protestant Ethic and the Spirit of Capitalism", _
                                   "The Origin of Species"}
        Dim replacement As String = """$&"""
        For Each title As String In titles
            Console.WriteLine(Regex.Replace(title, pattern, replacement))
        Next
    End Sub
End Module
' The example displays the following output:
'       "A Tale of Two Cities"
'       "The Hound of the Baskervilles"
'       "The Protestant Ethic and the Spirit of Capitalism"
'       "The Origin of Species"

Le modèle d'expression régulière ^(\w+\s?)+$ est défini comme indiqué dans le tableau suivant.

Le modèle de remplacement "$&" ajoute un guillemet littéral au début et à la fin de chaque correspondance.

Substitution du texte avant la correspondance

La substitution $` remplace la chaîne correspondante par la chaîne d'entrée entière avant la correspondance. Autrement dit, elle duplique la chaîne d'entrée jusqu'à la correspondance en supprimant le texte correspondant. N'importe quel texte qui suit le texte correspondant est inchangé dans la chaîne de résultat. S'il existe plusieurs correspondances dans une chaîne d'entrée, le texte de remplacement est dérivé de la chaîne d'entrée d'origine, plutôt que de la chaîne dans laquelle le texte a été remplacé par des correspondances précédentes. (Ceci est illustré dans l’exemple.) Si aucune correspondance n’est trouvée, la substitution $` n’a aucun effet.

L'exemple suivant utilise le modèle d'expression régulière \d+ pour faire correspondre une séquence d'un ou de plusieurs chiffres décimaux dans la chaîne d'entrée. La chaîne de remplacement $` remplace ces chiffres par le texte qui précède la correspondance.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "aa1bb2cc3dd4ee5";
      string pattern = @"\d+";
      string substitution = "$`";
      Console.WriteLine("Matches:");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);

      Console.WriteLine("Input string:  {0}", input);
      Console.WriteLine("Output string: " +
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//    Matches:
//       1 at position 2
//       2 at position 5
//       3 at position 8
//       4 at position 11
//       5 at position 14
//    Input string:  aa1bb2cc3dd4ee5
//    Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "aa1bb2cc3dd4ee5"
        Dim pattern As String = "\d+"
        Dim substitution As String = "$`"
        Console.WriteLine("Matches:")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
        Console.WriteLine("Input string:  {0}", input)
        Console.WriteLine("Output string: " + _
                          Regex.Replace(input, pattern, substitution))
    End Sub
End Module
' The example displays the following output:
'    Matches:
'       1 at position 2
'       2 at position 5
'       3 at position 8
'       4 at position 11
'       5 at position 14
'    Input string:  aa1bb2cc3dd4ee5
'    Output string: aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Dans cet exemple, la chaîne d'entrée "aa1bb2cc3dd4ee5" contient cinq correspondances. Le tableau suivant illustre comment la substitution $` entraîne le remplacement de chaque correspondance dans la chaîne d'entrée par le moteur des expressions régulières. Le texte inséré est affiché en gras dans la colonne de résultats.

Substitution du texte après la correspondance

La substitution $' remplace la chaîne correspondante par la chaîne d'entrée entière après la correspondance. Autrement dit, elle duplique la chaîne d'entrée après la correspondance en supprimant le texte correspondant. N'importe quel texte qui précède le texte correspondant est inchangé dans la chaîne de résultat. S'il n'y a pas de correspondance, la substitution $' n'a aucun effet.

L'exemple suivant utilise le modèle d'expression régulière \d+ pour faire correspondre une séquence d'un ou de plusieurs chiffres décimaux dans la chaîne d'entrée. La chaîne de remplacement $' remplace ces chiffres par le texte qui suit la correspondance.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "aa1bb2cc3dd4ee5";
      string pattern = @"\d+";
      string substitution = "$'";
      Console.WriteLine("Matches:");
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
      Console.WriteLine("Input string:  {0}", input);
      Console.WriteLine("Output string: " +
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//    Matches:
//       1 at position 2
//       2 at position 5
//       3 at position 8
//       4 at position 11
//       5 at position 14
//    Input string:  aa1bb2cc3dd4ee5
//    Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "aa1bb2cc3dd4ee5"
        Dim pattern As String = "\d+"
        Dim substitution As String = "$'"
        Console.WriteLine("Matches:")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
        Console.WriteLine("Input string:  {0}", input)
        Console.WriteLine("Output string: " + _
                          Regex.Replace(input, pattern, substitution))
    End Sub
End Module
' The example displays the following output:
'    Matches:
'       1 at position 2
'       2 at position 5
'       3 at position 8
'       4 at position 11
'       5 at position 14
'    Input string:  aa1bb2cc3dd4ee5
'    Output string: aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Dans cet exemple, la chaîne d'entrée "aa1bb2cc3dd4ee5" contient cinq correspondances. Le tableau suivant illustre comment la substitution $' entraîne le remplacement de chaque correspondance dans la chaîne d'entrée par le moteur des expressions régulières. Le texte inséré est affiché en gras dans la colonne de résultats.

Substitution du dernier groupe capturé

La substitution $+ remplace la chaîne correspondante par le dernier groupe capturé. S'il n'y a pas de groupes capturés ou si la valeur du dernier groupe capturé est String.Empty, la substitution $+ n'a aucun effet.

L'exemple suivant identifie des mots en double dans une chaîne et utilise la substitution $+ pour les remplacer par une occurrence unique du mot. L'option RegexOptions.IgnoreCase est utilisée pour vérifier que les mots, qui diffèrent en termes de casse mais qui sont identiques par ailleurs, sont considérés comme des doublons.

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.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)\s\1\b"
        Dim substitution As String = "$+"
        Dim input As String = "The the dog jumped over the fence fence."
        Console.WriteLine(Regex.Replace(input, pattern, substitution, _
                                        RegexOptions.IgnoreCase))
    End Sub
End Module
' The example displays the following output:
'      The dog jumped over the fence.

Le modèle d'expression régulière \b(\w+)\s\1\b est défini comme indiqué dans le tableau suivant.

Substitution de la chaîne d'entrée entière

La substitution $_ remplace la chaîne correspondante par la chaîne d'entrée entière. Autrement dit, elle supprime le texte correspondant et le remplace par la chaîne entière, notamment le texte correspondant.

L'exemple suivant correspond à un ou plusieurs chiffres décimaux dans la chaîne d'entrée. Il utilise la substitution $_ pour les remplacer par la chaîne d'entrée entière.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "ABC123DEF456";
      string pattern = @"\d+";
      string substitution = "$_";
      Console.WriteLine("Original string:          {0}", input);
      Console.WriteLine("String with substitution: {0}",
                        Regex.Replace(input, pattern, substitution));
   }
}
// The example displays the following output:
//       Original string:          ABC123DEF456
//       String with substitution: ABCABC123DEF456DEFABC123DEF456

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

Dans cet exemple, la chaîne d'entrée "ABC123DEF456" contient deux correspondances. Le tableau suivant illustre comment la substitution $_ entraîne le remplacement de chaque correspondance dans la chaîne d'entrée par le moteur des expressions régulières. Le texte inséré est affiché en gras dans la colonne de résultats.

Voir aussi

• Langage des expressions régulières - Aide-mémoire