Substitutions dans les expressions régulièresSubstitutions in Regular Expressions

Les substitutions sont des éléments de langage reconnus uniquement dans des modèles de remplacement.Substitutions are language elements that are recognized only within replacement patterns. 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.They use a regular expression pattern to define all or part of the text that is to replace matched text in the input string. Le modèle de remplacement peut se composer d'une ou plusieurs substitutions avec des caractères littéraux.The replacement pattern can consist of one or more substitutions along with literal characters. 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 .Replacement patterns are provided to overloads of the Regex.Replace method that have a replacement parameter and to the Match.Result method. Les méthodes remplacent le modèle correspondant par le modèle défini par le paramètre replacement .The methods replace the matched pattern with the pattern that is defined by the replacement parameter.

Le .NET Framework définit les éléments de substitution répertoriés dans le tableau suivant.The .NET Framework defines the substitution elements listed in the following table.

SubstitutionSubstitution DescriptionDescription
$ nombre$ number Inclut la dernière sous-chaîne correspondant au groupe de capture identifié par nombre, où nombre est une valeur décimale, dans la chaîne de remplacement.Includes the last substring matched by the capturing group that is identified by number, where number is a decimal value, in the replacement string. Pour plus d'informations, consultez Substitution d'un groupe numéroté.For more information, see Substituting a Numbered Group.
${ nom }${ name } Inclut la dernière sous-chaîne correspondant au groupe nommé désigné par (?<nom> ) dans la chaîne de remplacement.Includes the last substring matched by the named group that is designated by (?<name> ) in the replacement string. Pour plus d'informations, consultez Substitution d'un groupe nommé.For more information, see Substituting a Named Group.
$$ Inclut un littéral « $ » unique dans la chaîne de remplacement.Includes a single "$" literal in the replacement string. Pour plus d'informations, consultez Substitution d'un symbole « $ ».For more information, see Substituting a "$" Symbol.
$& Inclut une copie de la correspondance entière dans la chaîne de remplacement.Includes a copy of the entire match in the replacement string. Pour plus d'informations, consultez Substitution de la correspondance entière.For more information, see Substituting the Entire Match.
$` Inclut tout le texte de la chaîne d'entrée avant la correspondance dans la chaîne de remplacement.Includes all the text of the input string before the match in the replacement string. Pour plus d'informations, consultez Substitution du texte avant la correspondance.For more information, see Substituting the Text before the Match.
$'$' Inclut tout le texte de la chaîne d'entrée après la correspondance dans la chaîne de remplacement.Includes all the text of the input string after the match in the replacement string. Pour plus d'informations, consultez Substitution du texte après la correspondance.For more information, see Substituting the Text after the Match.
$+ Inclut le dernier groupe capturé dans la chaîne de remplacement.Includes the last group captured in the replacement string. Pour plus d'informations, consultez Substitution du dernier groupe capturé.For more information, see Substituting the Last Captured Group.
$$ Inclut la chaîne d'entrée entière dans la chaîne de remplacement.Includes the entire input string in the replacement string. Pour plus d'informations, consultez Substitution de la chaîne d'entrée entière.For more information, see Substituting the Entire Input String.

Éléments de substitution et modèles de remplacementSubstitution Elements and Replacement Patterns

Les substitutions sont les seules constructions particulières acceptées dans un modèle de remplacement.Substitutions are the only special constructs recognized in a replacement pattern. 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.None of the other regular expression language elements, including character escapes and the period (.), which matches any character, are supported. 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.Similarly, substitution language elements are recognized only in replacement patterns and are never valid in regular expression patterns.

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.The only character that can appear either in a regular expression pattern or in a substitution is the $ character, although it has a different meaning in each context. Dans un modèle d'expression régulière, $ est une ancre qui correspond à la fin de la chaîne.In a regular expression pattern, $ is an anchor that matches the end of the string. Dans un modèle de remplacement, $ indique le début d'une substitution.In a replacement pattern, $ indicates the beginning of a substitution.

Notes

Pour les fonctionnalités semblables à un modèle de remplacement dans une expression régulière, utilisez une référence arrière.For functionality similar to a replacement pattern within a regular expression, use a backreference. Pour plus d'informations sur les références arrières, consultez Constructions de références arrières.For more information about backreferences, see Backreference Constructs.

Substitution d'un groupe numérotéSubstituting a Numbered Group

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.The $number language element includes the last substring matched by the number capturing group in the replacement string, where number is the index of the capturing group. Par exemple, le modèle de remplacement $1 indique que la sous-chaîne correspondante sera remplacée par le premier groupe capturé.For example, the replacement pattern $1 indicates that the matched substring is to be replaced by the first captured group. Pour plus d’informations sur les groupes de capture numérotés, consultez Grouping Constructs.For more information about numbered capturing groups, see Grouping Constructs.

Tous les chiffres qui suivent $ sont interprétés comme appartenant au groupe nombre .All digits that follow $ are interpreted as belonging to the number group. Si ce n'est pas votre intention, vous pouvez remplacer un groupe nommé à la place.If this is not your intent, you can substitute a named group instead. 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 ».For example, you can use the replacement string ${1}1 instead of $11 to define the replacement string as the value of the first captured group along with the number "1". Pour plus d'informations, consultez Substitution d'un groupe nommé.For more information, see Substituting a Named Group.

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.Capturing groups that are not explicitly assigned names using the (?<name>) syntax are numbered from left to right starting at one. 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.Named groups are also numbered from left to right, starting at one greater than the index of the last unnamed group. Par exemple, dans l'expression régulière (\w)(?<digit>\d), l'index du groupe nommé digit est 2.For example, in the regular expression (\w)(?<digit>\d), the index of the digit named group is 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.If number does not specify a valid capturing group defined in the regular expression pattern, $number is interpreted as a literal character sequence that is used to replace each match.

L'exemple suivant utilise la substitution $nombre pour supprimer le symbole monétaire d'une valeur décimale.The following example uses the $number substitution to strip the currency symbol from a decimal value. 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 « , »).It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

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.The regular expression pattern \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* is defined as shown in the following table.

MotifPattern DescriptionDescription
\p{Sc}* Mettre en correspondance zéro ou plusieurs caractères de symbole monétaire.Match zero or more currency symbol characters.
\s? Mettre en correspondance zéro ou des espaces blancs.Match zero or one white-space characters.
\d+ Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits.
[.,]? Mettre en correspondance zéro ou un point ou une virgule.Match zero or one period or comma.
\d* Met en correspondance zéro ou plusieurs chiffres décimaux.Match zero or more decimal digits.
(\s?\d+[.,]?\d*) Mettre en correspondance un espace blanc suivi par un ou plusieurs chiffres décimaux, suivi par zéro ou un point ou une virgule, suivi par zéro ou plusieurs chiffres décimaux.Match a white space followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. Il s'agit du premier groupe de capture.This is the first capturing group. Étant donné que le modèle de remplacement est $1, l'appel à la méthode Regex.Replace remplace l'intégralité de la sous-chaîne correspondante par ce groupe capturé.Because the replacement pattern is $1, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Retour au débutBack to top

Substitution d'un groupe nomméSubstituting a Named Group

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>) .The ${name} language element substitutes the last substring matched by the name capturing group, where name is the name of a capturing group defined by the (?<name>) language element. Pour plus d’informations sur les groupes de capture nommés, consultez Grouping Constructs.For more information about named capturing groups, see 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é.If name doesn't specify a valid named capturing group defined in the regular expression pattern but consists of digits, ${name} is interpreted as a numbered group.

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.If name specifies neither a valid named capturing group nor a valid numbered capturing group defined in the regular expression pattern, ${name} is interpreted as a literal character sequence that is used to replace each match.

L'exemple suivant utilise la substitution ${nom} pour supprimer le symbole monétaire d'une valeur décimale.The following example uses the ${name} substitution to strip the currency symbol from a decimal value. 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 « , »).It removes currency symbols found at the beginning or end of a monetary value, and recognizes the two most common decimal separators ("." and ",").

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.The regular expression pattern \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* is defined as shown in the following table.

MotifPattern DescriptionDescription
\p{Sc}* Mettre en correspondance zéro ou plusieurs caractères de symbole monétaire.Match zero or more currency symbol characters.
\s? Mettre en correspondance zéro ou des espaces blancs.Match zero or one white-space characters.
\d+ Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits.
[.,]? Mettre en correspondance zéro ou un point ou une virgule.Match zero or one period or comma.
\d* Met en correspondance zéro ou plusieurs chiffres décimaux.Match zero or more decimal digits.
(?<amount>\s?\d[.,]?\d*) Mettre en correspondance un espace blanc, suivi par un ou plusieurs chiffres décimaux, suivi par zéro ou un point ou une virgule, suivi par zéro ou plusieurs chiffres décimaux.Match a white space, followed by one or more decimal digits, followed by zero or one period or comma, followed by zero or more decimal digits. C'est le groupe de capture nommé amount.This is the capturing group named amount. Étant donné que le modèle de remplacement est ${amount}, l'appel à la méthode Regex.Replace remplace l'intégralité de la sous-chaîne correspondante par ce groupe capturé.Because the replacement pattern is ${amount}, the call to the Regex.Replace method replaces the entire matched substring with this captured group.

Retour au débutBack to top

Substitution d'un caractère « $ »Substituting a "$" Character

La substitution $$ insère un caractère « $ » littéral dans la chaîne remplacée.The $$ substitution inserts a literal "$" character in the replaced string.

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.The following example uses the NumberFormatInfo object to determine the current culture's currency symbol and its placement in a currency string. Il génère alors à la fois dynamiquement un modèle d'expression régulière et un modèle de remplacement.It then builds both a regular expression pattern and a replacement pattern dynamically. 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.If the example is run on a computer whose current culture is en-US, it generates the regular expression pattern \b(\d+)(\.(\d+))? and the replacement pattern $$ $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.The replacement pattern replaces the matched text with a currency symbol and a space followed by the first and second captured groups.

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.The regular expression pattern \b(\d+)(\.(\d+))? is defined as shown in the following table.

MotifPattern DescriptionDescription
\b Démarrer la correspondance au début d'une limite de mot.Start the match at the beginning of a word boundary.
(\d+) Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits. Il s'agit du premier groupe de capture.This is the first capturing group.
\. Mettre en correspondance un point (le séparateur décimal).Match a period (the decimal separator).
(\d+) Mettre en correspondance un ou plusieurs chiffres décimaux.Match one or more decimal digits. Il s'agit du troisième groupe de capture.This is the third capturing group.
(\.(\d+))? Mettre en correspondance zéro ou une occurrence d'un point suivi par un ou plusieurs chiffres décimaux.Match zero or one occurrence of a period followed by one or more decimal digits. Il s'agit du deuxième groupe de capture.This is the second capturing group.

Substitution de la correspondance entièreSubstituting the Entire Match

La substitution $& inclut la correspondance entière dans la chaîne de remplacement.The $& substitution includes the entire match in the replacement string. Souvent, elle est utilisée pour ajouter une sous-chaîne au début ou à la fin de la chaîne correspondante.Often, it is used to add a substring to the beginning or end of the matched string. Par exemple, le modèle de remplacement ($&) ajoute des parenthèses au début et à la fin de chaque correspondance.For example, the ($&) replacement pattern adds parentheses to the beginning and end of each match. S'il n'y a pas de correspondance, la substitution $& n'a aucun effet.If there is no match, the $& substitution has no effect.

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.The following example uses the $& substitution to add quotation marks at the beginning and end of book titles stored in a string array.

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.The regular expression pattern ^(\w+\s?)+$ is defined as shown in the following table.

MotifPattern DescriptionDescription
^ Commencer la correspondance au début de la chaîne d'entrée.Start the match at the beginning of the input string.
(\w+\s?)+ Mettre en correspondance le modèle d'un ou plusieurs caractères de mot, suivis de zéro ou d'un espace blanc, une ou plusieurs fois.Match the pattern of one or more word characters followed by zero or one white-space characters one or more times.
$ Mettre en correspondance la fin de la chaîne d'entrée.Match the end of the input string.

Le modèle de remplacement "$&" ajoute un guillemet littéral au début et à la fin de chaque correspondance.The "$&" replacement pattern adds a literal quotation mark to the beginning and end of each match.

Retour au débutBack to top

Substitution du texte avant la correspondanceSubstituting the Text Before the Match

La substitution $` remplace la chaîne correspondante par la chaîne d'entrée entière avant la correspondance.The $` substitution replaces the matched string with the entire input string before the match. Autrement dit, elle duplique la chaîne d'entrée jusqu'à la correspondance en supprimant le texte correspondant.That is, it duplicates the input string up to the match while removing the matched text. N'importe quel texte qui suit le texte correspondant est inchangé dans la chaîne de résultat.Any text that follows the matched text is unchanged in the result string. 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.If there are multiple matches in an input string, the replacement text is derived from the original input string, rather than from the string in which text has been replaced by earlier matches. (Cet exemple en fournit une illustration.) S'il n'y a pas de correspondance, la substitution $` n'a aucun effet.(The example provides an illustration.) If there is no match, the $` substitution has no effect.

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.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. La chaîne de remplacement $` remplace ces chiffres par le texte qui précède la correspondance.The replacement string $` replaces these digits with the text that precedes the match.

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.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 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.The following table illustrates how the $` substitution causes the regular expression engine to replace each match in the input string. Le texte inséré est affiché en gras dans la colonne de résultats.Inserted text is shown in bold in the results column.

Faire correspondre àMatch PositionPosition Chaîne avant la correspondanceString before match Chaîne de résultatResult string
11 22 aaaa aaaabb2cc3dd4ee5aaaabb2cc3dd4ee5
22 55 aa1bbaa1bb aaaabbaa1bbcc3dd4ee5aaaabbaa1bbcc3dd4ee5
33 88 aa1bb2ccaa1bb2cc aaaabbaa1bbccaa1bb2ccdd4ee5aaaabbaa1bbccaa1bb2ccdd4ee5
44 1111 aa1bb2cc3ddaa1bb2cc3dd aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
55 1414 aa1bb2cc3dd4eeaa1bb2cc3dd4ee aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4eeaaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Retour au débutBack to top

Substitution du texte après la correspondanceSubstituting the Text After the Match

La substitution $' remplace la chaîne correspondante par la chaîne d'entrée entière après la correspondance.The $' substitution replaces the matched string with the entire input string after the match. Autrement dit, elle duplique la chaîne d'entrée après la correspondance en supprimant le texte correspondant.That is, it duplicates the input string after the match while removing the matched text. N'importe quel texte qui précède le texte correspondant est inchangé dans la chaîne de résultat.Any text that precedes the matched text is unchanged in the result string. S'il n'y a pas de correspondance, la substitution $' n'a aucun effet.If there is no match, the $' substitution has no effect.

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.The following example uses the regular expression pattern \d+ to match a sequence of one or more decimal digits in the input string. La chaîne de remplacement $' remplace ces chiffres par le texte qui suit la correspondance.The replacement string $' replaces these digits with the text that follows the match.

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.In this example, the input string "aa1bb2cc3dd4ee5" contains five matches. 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.The following table illustrates how the $' substitution causes the regular expression engine to replace each match in the input string. Le texte inséré est affiché en gras dans la colonne de résultats.Inserted text is shown in bold in the results column.

Faire correspondre àMatch PositionPosition Chaîne après la correspondanceString after match Chaîne de résultatResult string
11 22 bb2cc3dd4ee5bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5aabb2cc3dd4ee5bb2cc3dd4ee5
22 55 cc3dd4ee5cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
33 88 dd4ee5dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5
44 1111 ee5ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5
55 1414 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5eeaabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Retour au débutBack to top

Substitution du dernier groupe capturéSubstituting the Last Captured Group

La substitution $+ remplace la chaîne correspondante par le dernier groupe capturé.The $+ substitution replaces the matched string with the last captured group. 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.If there are no captured groups or if the value of the last captured group is String.Empty, the $+ substitution has no effect.

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.The following example identifies duplicate words in a string and uses the $+ substitution to replace them with a single occurrence of the word. 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.The RegexOptions.IgnoreCase option is used to ensure that words that differ in case but that are otherwise identical are considered duplicates.

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.The regular expression pattern \b(\w+)\s\1\b is defined as shown in the following table.

MotifPattern DescriptionDescription
\b Commencer la correspondance à la limite d'un mot.Begin the match at a word boundary.
(\w+) Mettre en correspondance un ou plusieurs caractères alphabétiques.Match one or more word characters. Il s'agit du premier groupe de capture.This is the first capturing group.
\s Mettre en correspondance un espace blanc.Match a white-space character.
\1 Mettre en correspondance le premier groupe capturé.Match the first captured group.
\b Terminer la correspondance à la limite d'un mot.End the match at a word boundary.

Retour au débutBack to top

Substitution de la chaîne d'entrée entièreSubstituting the Entire Input String

La substitution $_ remplace la chaîne correspondante par la chaîne d'entrée entière.The $_ substitution replaces the matched string with the entire input string. Autrement dit, elle supprime le texte correspondant et le remplace par la chaîne entière, notamment le texte correspondant.That is, it removes the matched text and replaces it with the entire string, including the matched text.

L'exemple suivant correspond à un ou plusieurs chiffres décimaux dans la chaîne d'entrée.The following example matches one or more decimal digits in the input string. Il utilise la substitution $_ pour les remplacer par la chaîne d'entrée entière.It uses the $_ substitution to replace them with the entire input string.

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.In this example, the input string "ABC123DEF456" contains two matches. 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.The following table illustrates how the $_ substitution causes the regular expression engine to replace each match in the input string. Le texte inséré est affiché en gras dans la colonne de résultats.Inserted text is shown in bold in the results column.

Faire correspondre àMatch PositionPosition Faire correspondre àMatch Chaîne de résultatResult string
11 33 123123 ABCABC123DEF456DEF456ABCABC123DEF456DEF456
22 55 456456 ABCABC123DEF456DEFABC123DEF456ABCABC123DEF456DEFABC123DEF456

Voir aussiSee also