Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Les substitutions sont des éléments de langage qui sont reconnus uniquement dans les modèles de remplacement. Ils utilisent un modèle d’expression régulière pour définir tout ou partie du texte qui doit remplacer le texte mis en correspondance 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érals. Les modèles de remplacement sont fournis aux surcharges de la Regex.Replace méthode qui ont un replacement paramètre et à la Match.Result méthode. Les méthodes remplacent le modèle mis en correspondance par le modèle défini par le replacement paramètre.
.NET définit les éléments de substitution répertoriés dans le tableau suivant.
| Remplacement | Descriptif |
|---|---|
| $ nombre | Inclut la dernière sous-chaîne mise en correspondance par le groupe de capture identifié par le nombre, où le nombre est une valeur décimale, dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement d’un groupe numéroté. |
| ${ name } | Inclut la dernière sous-chaîne mise en correspondance par le groupe nommé désigné par (?<son nom> ) dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement d’un groupe nommé. |
| $$ | Inclut un littéral « $ » unique dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement d’un symbole « $ ». |
| $& | Inclut une copie de la correspondance entière dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement de la correspondance entière. |
| $` | Inclut tout le texte de la chaîne d’entrée avant la correspondance dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement du texte avant la correspondance. |
| $' | Inclut tout le texte de la chaîne d’entrée après la correspondance dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement du texte après la correspondance. |
| $+ | Inclut le dernier groupe capturé dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement du dernier groupe capturé. |
| $_ | Inclut la chaîne d’entrée entière dans la chaîne de remplacement. Pour plus d’informations, consultez Remplacement de la chaîne d’entrée entière. |
Éléments de substitution et modèles de remplacement
Les substitutions sont les seules constructions spéciales reconnues dans un modèle de remplacement. Aucun des autres éléments du langage d’expression régulière, y compris les échappements de caractères et le point (.), qui correspond à n’importe quel caractère, sont pris en charge. De même, 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’expression régulière.
Le seul caractère pouvant 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.
Remarque
Pour des fonctionnalités similaires à un modèle de remplacement au sein d’une expression régulière, utilisez une référence backreference. Pour plus d’informations sur les références backreferences, consultez Constructions backreference.
Substitution d’un groupe numéroté
L’élément $de langage numérique inclut la dernière sous-chaîne mise en correspondance par le groupe de capture de numéros dans la chaîne de remplacement, où le nombre est l’index du groupe de capture. Par exemple, le modèle $1 de remplacement indique que la sous-chaîne correspondante doit être remplacée par le premier groupe capturé. Pour plus d’informations sur les groupes de capture numérotés, consultez Constructions de regroupement.
Tous les chiffres qui suivent $ sont interprétés comme appartenant au groupe de nombres . Si ce n’est pas votre intention, vous pouvez remplacer un groupe nommé à la place. Par exemple, vous pouvez utiliser la chaîne ${1}1 de remplacement au lieu de $11 définir la chaîne de remplacement comme valeur du premier groupe capturé, ainsi que le nombre « 1 ». Pour plus d’informations, consultez Remplacement d’un groupe nommé.
La capture de groupes qui ne sont pas explicitement attribués aux noms à l’aide de la (?< syntaxe de nom>) est numéroté de gauche à droite en commençant à un. Les groupes nommés sont également numérotés de gauche à droite, en commençant à un plus grand que l’index du dernier groupe sans nom. Par exemple, dans l’expression (\w)(?<digit>\d)régulière, l’index du digit groupe nommé est 2.
Si le nombre ne spécifie pas de groupe de capture valide défini dans le modèle d’expression régulière, $le nombre est interprété comme une séquence de caractères littérale utilisée pour remplacer chaque correspondance.
L’exemple suivant utilise la $ substitution de nombre pour supprimer le symbole monétaire d’une valeur décimale. Il 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.
| Modèle | Descriptif |
|---|---|
\p{Sc}* |
Mettre en correspondance zéro ou plusieurs caractères de symbole monétaire. |
\s? |
Mettre en correspondance zéro ou des espaces blancs. |
\d+ |
Mettre en correspondance un ou plusieurs chiffres décimaux. |
[.,]? |
Mettre en correspondance zéro ou une virgule. |
\d* |
Met en correspondance zéro ou plusieurs chiffres décimaux. |
(\s?\d+[.,]?\d*) |
Mettre en correspondance un espace blanc suivi d’un ou plusieurs chiffres décimaux, suivis de zéro ou d’une virgule, suivis de zéro ou de plusieurs chiffres décimaux. Il s'agit du premier groupe de capture. Étant donné que le modèle de remplacement est $1, l’appel à la Regex.Replace méthode remplace la sous-chaîne correspondante entière par ce groupe capturé. |
Substitution d’un groupe nommé
L’élément ${ de langue de nom} remplace la dernière sous-chaîne mise en correspondance par le groupe de capture de noms, où le nom est le nom d’un groupe de capture défini par l’élément (?< de langue de nom>). Pour plus d’informations sur les groupes de capture nommés, consultez Constructions de regroupement.
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, ${le nom} est interprété comme un 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, ${le nom} est interprété comme une séquence de caractères littérale utilisée pour remplacer chaque correspondance.
L’exemple suivant utilise la substitution de ${nom} pour supprimer le symbole monétaire d’une valeur décimale. Il 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.
| Modèle | Descriptif |
|---|---|
\p{Sc}* |
Mettre en correspondance zéro ou plusieurs caractères de symbole monétaire. |
\s? |
Mettre en correspondance zéro ou des espaces blancs. |
\d+ |
Mettre en correspondance un ou plusieurs chiffres décimaux. |
[.,]? |
Mettre en correspondance zéro ou une virgule. |
\d* |
Met en correspondance zéro ou plusieurs chiffres décimaux. |
(?<amount>\s?\d[.,]?\d*) |
Mettre en correspondance un espace blanc, suivi d’un ou plusieurs chiffres décimaux, suivis de zéro ou d’une virgule, suivis de zéro ou de plusieurs chiffres décimaux. Il s’agit du groupe de capture nommé amount. Étant donné que le modèle de remplacement est ${amount}, l’appel à la Regex.Replace méthode remplace la sous-chaîne correspondante entière par ce groupe capturé. |
Remplacement 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 placement dans une chaîne monétaire. Il génère ensuite à la fois un modèle d’expression régulière et un modèle de remplacement dynamiquement. Si l’exemple est exécuté sur un ordinateur dont la culture actuelle est en-US, il génère le modèle \b(\d+)(\.(\d+))? d’expression régulière et le modèle $$ $1$2de remplacement. Le modèle de remplacement remplace le texte mis en correspondance par un symbole monétaire et un espace suivi des premiers et deuxième 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($"{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.
| Modèle | Descriptif |
|---|---|
\b |
Démarrez la correspondance au début d’une limite de mot. |
(\d+) |
Mettre en correspondance un ou plusieurs chiffres décimaux. Il s'agit du premier groupe de capture. |
\. |
Mettre en correspondance un point (séparateur décimal). |
(\d+) |
Mettre en correspondance un ou plusieurs chiffres décimaux. Il s'agit du troisième groupe de capture. |
(\.(\d+))? |
Mettre en correspondance zéro ou une occurrence d’une période suivie d’un ou plusieurs chiffres décimaux. Il s'agit du deuxième groupe de capture. |
Substitution de la correspondance entière
La $& substitution inclut la correspondance entière dans la chaîne de remplacement. Souvent, il est utilisé 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 des titres de livre 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.
| Modèle | Descriptif |
|---|---|
^ |
Démarrez la correspondance au début de la chaîne d’entrée. |
(\w+\s?)+ |
Mettre en correspondance le modèle d’un ou plusieurs caractères de mots suivis de zéro ou d’un espace blanc une ou plusieurs fois. |
$ |
Mettre en correspondance la fin de la chaîne d'entrée. |
Le "$&" modèle de remplacement ajoute un guillemet littéral au début et à la fin de chaque correspondance.
Remplacement 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, il duplique la chaîne d’entrée jusqu’à la correspondance lors de la suppression du texte correspondant. Tout texte qui suit le texte mis en correspondance n’est pas modifié 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 antérieures. (L’exemple fournit une illustration.) S’il n’y a pas de correspondance, la $` substitution n’a aucun effet.
L’exemple suivant utilise le modèle \d+ d’expression régulière pour faire correspondre une séquence d’un ou 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($" {match.Value} at position {match.Index}");
Console.WriteLine($"Input string: {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 "aa1bb2cc3dd4ee5" d’entrée contient cinq correspondances. Le tableau suivant illustre la façon dont la $` substitution entraîne le remplacement du moteur d’expression régulière à remplacer chaque correspondance dans la chaîne d’entrée. Le texte inséré est affiché en gras dans la colonne de résultats.
| Correspond à | Poste | Chaîne avant correspondance | Chaîne de résultat |
|---|---|---|---|
| 1 | 2 | Aa | aaaabb2cc3dd4ee5 |
| 2 | 5 | aa1bb | aaaabbaa1bbcc3dd4ee5 |
| 3 | 8 | aa1bb2cc | aaaabbaa1bbccaa1bb2ccdd4ee5 |
| 4 | 11 | aa1bb2cc3ddd | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5 |
| 5 | 14 | aa1bb2cc3dd4ee | aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee |
Remplacement 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, il duplique la chaîne d’entrée après la correspondance lors de la suppression du texte correspondant. Tout texte qui précède le texte mis en correspondance n’est pas modifié 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+ d’expression régulière pour faire correspondre une séquence d’un ou 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($" {match.Value} at position {match.Index}");
Console.WriteLine($"Input string: {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 "aa1bb2cc3dd4ee5" d’entrée contient cinq correspondances. Le tableau suivant illustre la façon dont la $' substitution entraîne le remplacement du moteur d’expression régulière à remplacer chaque correspondance dans la chaîne d’entrée. Le texte inséré est affiché en gras dans la colonne de résultats.
| Correspond à | Poste | Chaîne après correspondance | Chaîne de résultat |
|---|---|---|---|
| 1 | 2 | bb2cc3dd4ee5 | aabb2cc3dd4ee5bb2cc3dd4ee5 |
| 2 | 5 | cc3dd4ee5 | aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5 cc3dd4ee5 |
| 3 | 8 | dd4ee5 | aabb2cc3d4ee5bbcc3dd4ee5ccdd4ee5cc dd4ee5dd4ee5 |
| 4 | 11 | ee5 | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5 ee5 |
| 5 | 14 | String.Empty | aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee |
Remplacement du dernier groupe capturé
La $+ substitution remplace la chaîne mise en correspondance par le dernier groupe capturé. S’il n’existe aucun groupe capturé ou si la valeur du dernier groupe capturé est String.Empty, la $+ substitution n’a aucun effet.
L’exemple suivant identifie les mots dupliqués 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 s’assurer que les mots qui diffèrent dans le cas, mais qui sont autrement identiques 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.
| Modèle | Descriptif |
|---|---|
\b |
Commencer la correspondance à la limite d'un mot. |
(\w+) |
Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du premier groupe de capture. |
\s |
Mettre en correspondance un espace blanc. |
\1 |
Mettre en correspondance le premier groupe capturé. |
\b |
Terminer la correspondance à la limite d'un mot. |
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, il supprime le texte mis en correspondance et le remplace par la chaîne entière, y compris le texte mis en correspondance.
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: {input}");
Console.WriteLine($"String with substitution: {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 "ABC123DEF456" d’entrée contient deux correspondances. Le tableau suivant illustre la façon dont la $_ substitution entraîne le remplacement du moteur d’expression régulière à remplacer chaque correspondance dans la chaîne d’entrée. Le texte inséré est affiché en gras dans la colonne de résultats.
| Correspond à | Poste | Correspond à | Chaîne de résultat |
|---|---|---|---|
| 1 | 3 | 123 | ABCABC123DEF456DEF456 |
| 2 | 5 | 456 | ABCABC123DEF456DEFABC123DEF456 |
Voir aussi
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
