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 expressions régulières fournissent une méthode puissante, flexible et efficace pour le traitement du texte. La notation complète de correspondance de modèles d’expressions régulières vous permet d’analyser rapidement de grandes quantités de texte à :
- Recherchez des modèles de caractères spécifiques.
- Validez le texte pour vous assurer qu’il correspond à un modèle prédéfini (par exemple, une adresse e-mail).
- Extraire, modifier, remplacer ou supprimer des sous-chaînes de texte.
- Ajoutez des chaînes extraites à une collection pour générer un rapport.
Pour de nombreuses applications qui traitent des chaînes ou qui analysent de grands blocs de texte, les expressions régulières sont un outil indispensable.
Fonctionnement des expressions régulières
La pièce centrale du traitement du texte avec des expressions régulières est le moteur d’expression régulière, qui est représenté par l’objet System.Text.RegularExpressions.Regex dans .NET. Au minimum, le traitement du texte à l’aide d’expressions régulières nécessite que le moteur d’expression régulière soit fourni avec les deux éléments d’informations suivants :
Modèle d’expression régulière à identifier dans le texte.
Dans .NET, les modèles d’expression régulière sont définis par une syntaxe ou un langage spécial, qui est compatible avec les expressions régulières Perl 5 et ajoute des fonctionnalités supplémentaires telles que la correspondance de droite à gauche. Pour plus d’informations, consultez Le langage d’expression régulière - Informations de référence rapides.
Texte à analyser pour le modèle d’expression régulière.
Les méthodes de la Regex classe vous permettent d’effectuer les opérations suivantes :
Déterminez si le modèle d’expression régulière se produit dans le texte d’entrée en appelant la Regex.IsMatch méthode. Pour obtenir un exemple qui utilise la IsMatch méthode de validation du texte, consultez How to : Verify that Strings Are in Valid Email Format.
Récupérez une ou toutes les occurrences de texte qui correspondent au modèle d’expression régulière en appelant ou Regex.MatchRegex.Matches méthode. L’ancienne méthode retourne un System.Text.RegularExpressions.Match objet qui fournit des informations sur le texte correspondant. Ce dernier retourne un MatchCollection objet qui contient un System.Text.RegularExpressions.Match objet pour chaque correspondance trouvée dans le texte analysé.
Remplacez le texte qui correspond au modèle d’expression régulière en appelant la Regex.Replace méthode. Pour obtenir des exemples qui utilisent la méthode pour modifier les Replace formats de date et supprimer des caractères non valides d’une chaîne, consultez How to : Strip Invalid Characters from a String and Example : Changing Date Formats.
Pour obtenir une vue d’ensemble du modèle objet d’expression régulière, consultez Le modèle objet Expression régulière.
Pour plus d’informations sur la langue d’expression régulière, consultez La langue de l’expression régulière - Informations de référence rapide ou télécharger et imprimer l’une des brochures suivantes :
- Informations de référence rapides au format Word (.docx)
- Informations de référence rapides au format PDF (.pdf)
Exemples d’expressions régulières
La String classe inclut des méthodes de recherche et de remplacement de chaîne que vous pouvez utiliser lorsque vous souhaitez localiser des chaînes littérales dans une chaîne plus grande. Les expressions régulières sont les plus utiles soit lorsque vous souhaitez localiser l’une des sous-chaînes d’une chaîne plus grande, soit lorsque vous souhaitez identifier des modèles dans une chaîne, comme l’illustrent les exemples suivants.
Avertissement
Lorsque vous utilisez System.Text.RegularExpressions pour traiter une entrée non approuvée, passez un délai d’expiration. Un utilisateur malveillant peut fournir une entrée à RegularExpressions
, provoquant une attaque par déni de service. Les API d’infrastructure ASP.NET Core qui utilisent RegularExpressions
passent un délai d’expiration.
Conseil / Astuce
L’espace System.Web.RegularExpressions de noms contient un certain nombre d’objets d’expression régulière qui implémentent des modèles d’expression régulière prédéfinis pour l’analyse de chaînes à partir de documents HTML, XML et ASP.NET. Par exemple, la TagRegex classe identifie les balises de début dans une chaîne et la CommentRegex classe identifie ASP.NET commentaires dans une chaîne.
Exemple 1 : Remplacer les sous-chaînes
Supposons qu’une liste de diffusion contient des noms qui incluent parfois un titre (M., Mme, Miss ou Ms.) ainsi qu’un prénom et un nom. Supposons que vous ne souhaitez pas inclure les titres lorsque vous générez des étiquettes d’enveloppe à partir de la liste. Dans ce cas, vous pouvez utiliser une expression régulière pour supprimer les titres, comme l’illustre l’exemple suivant :
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";
string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels",
"Abraham Adams", "Ms. Nicole Norris" };
foreach (string name in names)
Console.WriteLine(Regex.Replace(name, pattern, String.Empty));
}
}
// The example displays the following output:
// Henry Hunt
// Sara Samuels
// Abraham Adams
// Nicole Norris
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
Dim names() As String = {"Mr. Henry Hunt", "Ms. Sara Samuels", _
"Abraham Adams", "Ms. Nicole Norris"}
For Each name As String In names
Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
Next
End Sub
End Module
' The example displays the following output:
' Henry Hunt
' Sara Samuels
' Abraham Adams
' Nicole Norris
Le modèle (Mr\.? |Mrs\.? |Miss |Ms\.? )
d’expression régulière correspond à toute occurrence de « Mr », « M. », « Mme », « Mme », « Miss », « Ms » ou « Ms ». L’appel à la Regex.Replace méthode remplace la chaîne String.Emptycorrespondante par ; en d’autres termes, elle la supprime de la chaîne d’origine.
Exemple 2 : Identifier les mots dupliqués
La duplication accidentelle des mots est une erreur courante que les enregistreurs font. Utilisez une expression régulière pour identifier les mots dupliqués, comme l’illustre l’exemple suivant :
using System;
using System.Text.RegularExpressions;
public class Class1
{
public static void Main()
{
string pattern = @"\b(\w+?)\s\1\b";
string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine($"{match.Value} (duplicates '{match.Groups[1].Value}') at position {match.Index}");
}
}
// The example displays the following output:
// This this (duplicates 'This') at position 0
// a a (duplicates 'a') at position 66
Imports System.Text.RegularExpressions
Module modMain
Public Sub Main()
Dim pattern As String = "\b(\w+?)\s\1\b"
Dim input As String = "This this is a nice day. What about this? This tastes good. I saw a a dog."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
match.Value, match.Groups(1).Value, match.Index)
Next
End Sub
End Module
' The example displays the following output:
' This this (duplicates 'This') at position 0
' a a (duplicates 'a') at position 66
Le modèle \b(\w+?)\s\1\b
d’expression régulière peut être interprété comme suit :
Modèle | Interprétation |
---|---|
\b |
Commencer à la limite d'un mot. |
(\w+?) |
Mettre en correspondance un ou plusieurs caractères de mot, mais aussi peu de caractères que possible. Ensemble, ils forment un groupe qui peut être appelé \1 . |
\s |
Mettre en correspondance un espace blanc. |
\1 |
Correspond à la sous-chaîne égale au groupe nommé \1 . |
\b |
Mettre en correspondance la limite d'un mot. |
La Regex.Matches méthode est appelée avec les options d’expression régulière définies sur RegexOptions.IgnoreCase. Par conséquent, l’opération de correspondance ne respecte pas la casse et l’exemple identifie la sous-chaîne « This this » comme une duplication.
La chaîne d’entrée inclut la sous-chaîne « ceci ? C’est ça. Toutefois, en raison de la marque de ponctuation intermédiaire, elle n’est pas identifiée comme une duplication.
Exemple 3 : Générer dynamiquement une expression régulière sensible à la culture
L’exemple suivant illustre la puissance des expressions régulières combinée à la flexibilité offerte par . Fonctionnalités de globalisation de NET. Il utilise l’objet NumberFormatInfo pour déterminer le format des valeurs monétaires dans la culture actuelle du système. Il utilise ensuite ces informations pour construire dynamiquement une expression régulière qui extrait les valeurs monétaires du texte. Pour chaque correspondance, il extrait le sous-groupe qui contient la chaîne numérique uniquement, le convertit en valeur Decimal et calcule un total en cours d’exécution.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
// Define text to be parsed.
string input = "Office expenses on 2/13/2008:\n" +
"Paper (500 sheets) $3.95\n" +
"Pencils (box of 10) $1.00\n" +
"Pens (box of 10) $4.49\n" +
"Erasers $2.19\n" +
"Ink jet printer $69.95\n\n" +
"Total Expenses $ 81.58\n";
// Get current culture's NumberFormatInfo object.
NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
// Assign needed property values to variables.
string currencySymbol = nfi.CurrencySymbol;
bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
string groupSeparator = nfi.CurrencyGroupSeparator;
string decimalSeparator = nfi.CurrencyDecimalSeparator;
// Form regular expression pattern.
string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") +
@"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" +
Regex.Escape(decimalSeparator) + "[0-9]+)?)" +
(! symbolPrecedesIfPositive ? currencySymbol : "");
Console.WriteLine( "The regular expression pattern is:");
Console.WriteLine(" " + pattern);
// Get text that matches regular expression pattern.
MatchCollection matches = Regex.Matches(input, pattern,
RegexOptions.IgnorePatternWhitespace);
Console.WriteLine($"Found {matches.Count} matches.");
// Get numeric string, convert it to a value, and add it to List object.
List<decimal> expenses = new List<Decimal>();
foreach (Match match in matches)
expenses.Add(Decimal.Parse(match.Groups[1].Value));
// Determine whether total is present and if present, whether it is correct.
decimal total = 0;
foreach (decimal value in expenses)
total += value;
if (total / 2 == expenses[expenses.Count - 1])
Console.WriteLine($"The expenses total {expenses[expenses.Count - 1]:C2}.");
else
Console.WriteLine($"The expenses total {total:C2}.");
}
}
// The example displays the following output:
// The regular expression pattern is:
// \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
// Found 6 matches.
// The expenses total $81.58.
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Text.RegularExpressions
Public Module Example
Public Sub Main()
' Define text to be parsed.
Dim input As String = "Office expenses on 2/13/2008:" + vbCrLf + _
"Paper (500 sheets) $3.95" + vbCrLf + _
"Pencils (box of 10) $1.00" + vbCrLf + _
"Pens (box of 10) $4.49" + vbCrLf + _
"Erasers $2.19" + vbCrLf + _
"Ink jet printer $69.95" + vbCrLf + vbCrLf + _
"Total Expenses $ 81.58" + vbCrLf
' Get current culture's NumberFormatInfo object.
Dim nfi As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
' Assign needed property values to variables.
Dim currencySymbol As String = nfi.CurrencySymbol
Dim symbolPrecedesIfPositive As Boolean = CBool(nfi.CurrencyPositivePattern Mod 2 = 0)
Dim groupSeparator As String = nfi.CurrencyGroupSeparator
Dim decimalSeparator As String = nfi.CurrencyDecimalSeparator
' Form regular expression pattern.
Dim pattern As String = Regex.Escape(CStr(IIf(symbolPrecedesIfPositive, currencySymbol, ""))) + _
"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + _
Regex.Escape(decimalSeparator) + "[0-9]+)?)" + _
CStr(IIf(Not symbolPrecedesIfPositive, currencySymbol, ""))
Console.WriteLine("The regular expression pattern is: ")
Console.WriteLine(" " + pattern)
' Get text that matches regular expression pattern.
Dim matches As MatchCollection = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
Console.WriteLine("Found {0} matches. ", matches.Count)
' Get numeric string, convert it to a value, and add it to List object.
Dim expenses As New List(Of Decimal)
For Each match As Match In matches
expenses.Add(Decimal.Parse(match.Groups.Item(1).Value))
Next
' Determine whether total is present and if present, whether it is correct.
Dim total As Decimal
For Each value As Decimal In expenses
total += value
Next
If total / 2 = expenses(expenses.Count - 1) Then
Console.WriteLine("The expenses total {0:C2}.", expenses(expenses.Count - 1))
Else
Console.WriteLine("The expenses total {0:C2}.", total)
End If
End Sub
End Module
' The example displays the following output:
' The regular expression pattern is:
' \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
' Found 6 matches.
' The expenses total $81.58.
Sur un ordinateur dont la culture actuelle est l’anglais - États-Unis (en-US), l’exemple génère dynamiquement l’expression \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
régulière . Ce modèle d’expression régulière peut être interprété comme suit :
Modèle | Interprétation |
---|---|
\$ |
Recherchez une occurrence unique du symbole dollar ($ ) dans la chaîne d’entrée. La chaîne de modèle d’expression régulière inclut une barre oblique inverse pour indiquer que le symbole dollar doit être interprété littéralement plutôt que comme une ancre d’expression régulière. Le $ symbole seul indiquerait que le moteur d’expression régulière doit essayer de commencer sa correspondance à la fin d’une chaîne. Pour vous assurer que le symbole monétaire de la culture actuelle n’est pas mal interprété comme un symbole d’expression régulière, l’exemple appelle la Regex.Escape méthode pour échapper au caractère. |
\s* |
Recherchez zéro occurrence ou plus d’un caractère d’espace blanc. |
[-+]? |
Recherchez zéro ou une occurrence d’un signe positif ou négatif. |
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) |
Les parenthèses externes définissent cette expression comme un groupe de capture ou une sous-expression. Si une correspondance est trouvée, des informations sur cette partie de la chaîne correspondante peuvent être récupérées à partir du deuxième Group objet de l’objet GroupCollection retourné par la Match.Groups propriété. Le premier élément de la collection représente la correspondance entière. |
[0-9]{0,3} |
Recherchez zéro à trois occurrences des chiffres décimaux 0 à 9. |
(,[0-9]{3})* |
Recherchez zéro ou plusieurs occurrences d’un séparateur de groupe suivi de trois chiffres décimaux. |
\. |
Recherchez une occurrence unique du séparateur décimal. |
[0-9]+ |
Recherchez un ou plusieurs chiffres décimaux. |
(\.[0-9]+)? |
Recherchez zéro ou une occurrence du séparateur décimal suivi d’au moins un chiffre décimal. |
Si chaque sous-modèle est trouvé dans la chaîne d’entrée, la correspondance réussit et un Match objet qui contient des informations sur la correspondance est ajouté à l’objet MatchCollection .
Articles connexes
Titre | Descriptif |
---|---|
Langage d’expression régulière - Référence rapide | Fournit des informations sur l’ensemble de caractères, d’opérateurs et de constructions que vous pouvez utiliser pour définir des expressions régulières. |
Modèle objet d'expression régulière | Fournit des informations et des exemples de code qui illustrent comment utiliser les classes d’expression régulière. |
Comportement détaillé des expressions régulières | Fournit des informations sur les fonctionnalités et le comportement des expressions régulières .NET. |
Utiliser des expressions régulières dans Visual Studio |