Regex.Match Méthode

Définition

Recherche dans une chaîne d'entrée une sous-chaîne qui correspond à un modèle d'expression régulière et retourne la première occurrence sous forme d'objet Match unique.Searches an input string for a substring that matches a regular expression pattern and returns the first occurrence as a single Match object.

Surcharges

Match(String, String, RegexOptions, TimeSpan)

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Match(String, Int32, Int32)

Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée et en recherchant uniquement le nombre spécifié de caractères.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String, RegexOptions)

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance spécifiées.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, Int32)

Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée dans la chaîne.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String)

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée dans le constructeur Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, String)

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions, TimeSpan)

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance et l'intervalle de délai d'attente spécifiés.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);
public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);
static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.The string to search for a match.

pattern
String

Modèle d’expression régulière à mettre en correspondance.The regular expression pattern to match.

options
RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Retours

Objet qui contient des informations sur la correspondance.An object that contains information about the match.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.A regular expression parsing error occurred.

input ou pattern est null.input or pattern is null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.options is not a valid bitwise combination of RegexOptions values.

- ou --or- matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.matchTimeout is negative, zero, or greater than approximately 24 days.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

La méthode Match(String, String, RegexOptions, TimeSpan) retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée.The Match(String, String, RegexOptions, TimeSpan) method returns the first substring that matches a regular expression pattern in an input string. Pour plus d’informations sur les éléments de langage utilisés pour générer un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

La méthode Match(String, String, RegexOptions, TimeSpan) statique est équivalente à la construction d’un objet Regex avec le constructeur Regex(String, RegexOptions, TimeSpan) et à l’appel de la méthode Match(String) de l’instance.The static Match(String, String, RegexOptions, TimeSpan) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions, TimeSpan) constructor and calling the instance Match(String) method.

Le paramètre pattern se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez .NET Framework des expressions régulières et le langage des expressions régulières-aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété Success de l’objet Match retourné.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Si une correspondance est trouvée, la propriété Value de l’objet Match retourné contient la sous-chaîne de input qui correspond au modèle d’expression régulière.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.If no match is found, its value is String.Empty.

Cette méthode retourne la première sous-chaîne trouvée dans input qui correspond au modèle d’expression régulière.This method returns the first substring found in input that matches the regular expression pattern. Vous pouvez récupérer les correspondances suivantes en appelant de façon répétée la méthode NextMatch de l’objet Match retourné.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String, String, RegexOptions).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

Le paramètre matchTimeout spécifie la durée pendant laquelle une méthode de critères spéciaux doit tenter de trouver une correspondance avant d’expirer. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui reposent sur une rétroaction excessive de se bloquer lorsqu’elles traitent une entrée qui contient des correspondances proches.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Pour plus d’informations, consultez meilleures pratiques pour les expressions régulières et rétroaction.For more information, see Best Practices for Regular Expressions and Backtracking. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une exception RegexMatchTimeoutException.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’attente par défaut définie pour le domaine d’application dans lequel la méthode s’exécute.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notes pour les appelants

Nous vous recommandons de définir le paramètre matchTimeout sur une valeur appropriée, par exemple deux secondes.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Si vous désactivez les délais d’attente en spécifiant InfiniteMatchTimeout, le moteur d’expression régulière offre des performances légèrement meilleures.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. Toutefois, vous devez désactiver les délais d’expiration uniquement dans les conditions suivantes :However, you should disable time-outs only under the following conditions: -Lorsque l’entrée traitée par une expression régulière est dérivée d’une source connue et approuvée ou se compose d’un texte statique.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Cela exclut le texte qui a été saisi dynamiquement par les utilisateurs.This excludes text that has been dynamically input by users.

-Lorsque le modèle d’expression régulière a été minutieusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer une rétroaction excessive lors du traitement d’une correspondance proche.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Voir aussi

Match(String, Int32, Int32)

Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée et en recherchant uniquement le nombre spécifié de caractères.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);
public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);
member this.Match : string * int * int -> System.Text.RegularExpressions.Match
Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.The string to search for a match.

beginning
Int32

Position du caractère de base zéro dans la chaîne d'entrée qui définit la position la plus à gauche à parcourir.The zero-based character position in the input string that defines the leftmost position to be searched.

length
Int32

Nombre de caractères dans la sous-chaîne à inclure dans la recherche.The number of characters in the substring to include in the search.

Retours

Objet qui contient des informations sur la correspondance.An object that contains information about the match.

Exceptions

input a la valeur null.input is null.

beginning est inférieur à zéro ou supérieur à la longueur de input.beginning is less than zero or greater than the length of input.

- ou --or- length est inférieur à zéro ou supérieur à la longueur de input.length is less than zero or greater than the length of input.

- ou --or- beginning+length-1 identifie un emplacement situé en dehors de la plage de input.beginning+length-1 identifies a position that is outside the range of input.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

La méthode Match(String, Int32, Int32) retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une partie d’une chaîne d’entrée.The Match(String, Int32, Int32) method returns the first substring that matches a regular expression pattern in a portion of an input string. Pour plus d’informations sur les éléments de langage utilisés pour générer un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Le modèle d’expression régulière pour lequel la méthode Match(String, Int32, Int32) recherche est défini par l’appel à l’un des constructeurs de classe Regex.The regular expression pattern for which the Match(String, Int32, Int32) method searches is defined by the call to one of the Regex class constructors. Pour plus d’informations sur les éléments qui peuvent former un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

La méthode Match(String, Int32, Int32) recherche la partie de input définie par les paramètres beginning et length pour le modèle d’expression régulière.The Match(String, Int32, Int32) method searches the portion of input defined by the beginning and length parameters for the regular expression pattern. beginning définit toujours l’index du caractère le plus à gauche à inclure dans la recherche, et length définit le nombre maximal de caractères à rechercher.beginning always defines the index of the leftmost character to include in the search, and length defines the maximum number of characters to search. Ensemble, ils définissent la plage de la recherche.Together, they define the range of the search. Si la recherche s’effectue de gauche à droite (valeur par défaut), le moteur des expressions régulières recherche à partir du caractère au niveau de l’index beginning le caractère à l’index beginning + length-1.If the search proceeds from left to right (the default), the regular expression engine searches from the character at index beginning to the character at index beginning + length - 1. Si le moteur d’expression régulière a été instancié à l’aide de l’option RegexOptions.RightToLeft pour que la recherche s’effectue de droite à gauche, le moteur d’expression régulière recherche à partir du caractère à l’index beginning + length-1 au caractère au niveau de l’index beginning.If the regular expression engine was instantiated by using the RegexOptions.RightToLeft option so that the search proceeds from right to left, the regular expression engine searches from the character at index beginning + length - 1 to the character at index beginning. Cette méthode retourne la première correspondance trouvée dans cette plage.This method returns the first match that it finds within this range. Vous pouvez récupérer les correspondances suivantes en appelant de façon répétée la méthode Match.NextMatch de l’objet Match retourné.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété Success de l’objet Match retourné.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Si une correspondance est trouvée, la propriété Value de l’objet Match retourné contient la sous-chaîne de input qui correspond au modèle d’expression régulière.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.If no match is found, its value is String.Empty.

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération de correspondance dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si vous ne définissez pas de valeur de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse la valeur de délai d’attente définie pour le domaine d’application dans lequel l’objet Regex est créé.If you do not set a time-out value when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si aucun délai d’attente n’est défini dans l’appel de constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Voir aussi

Match(String, String, RegexOptions)

Recherche dans la chaîne d'entrée la première occurrence de l'expression régulière spécifiée, en utilisant les options de correspondance spécifiées.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);
public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);
static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.The string to search for a match.

pattern
String

Modèle d’expression régulière à mettre en correspondance.The regular expression pattern to match.

options
RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.A bitwise combination of the enumeration values that provide options for matching.

Retours

Objet qui contient des informations sur la correspondance.An object that contains information about the match.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.A regular expression parsing error occurred.

input ou pattern est null.input or pattern is null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Exemples

L’exemple suivant définit une expression régulière qui correspond à des mots commençant par la lettre « a ».The following example defines a regular expression that matches words beginning with the letter "a". Elle utilise l’option RegexOptions.IgnoreCase pour s’assurer que l’expression régulière localise des mots commençant par un « a » majuscule et un « a » minuscule.It uses the RegexOptions.IgnoreCase option to ensure that the regular expression locates words beginning with both an uppercase "a" and a lowercase "a".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\ba\w*\b";
      string input = "An extraordinary day dawns with each new day.";
      Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
      if (m.Success)
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
   }
}
// The example displays the following output:
//        Found 'An' at position 0.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

Le modèle d'expression régulière \ba\w*\b est interprété comme indiqué dans le tableau suivant.The regular expression pattern \ba\w*\b is interpreted as shown in the following table.

MotifPattern DescriptionDescription
\b Commencer la correspondance à la limite d'un mot.Begin the match at a word boundary.
a Correspond au caractère « a ».Match the character "a".
\w* Correspond à zéro, un ou plusieurs caractères alphabétiques.Match zero, one, or more word characters.
\b Terminer la correspondance à la limite d'un mot.End the match at a word boundary.

Remarques

La méthode Match(String, String, RegexOptions) retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée.The Match(String, String, RegexOptions) method returns the first substring that matches a regular expression pattern in an input string. Pour plus d’informations sur les éléments de langage utilisés pour générer un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

La méthode Match(String, String, RegexOptions) statique est équivalente à la construction d’un objet Regex avec le constructeur Regex(String, RegexOptions) et à l’appel de la méthode Match(String) de l’instance.The static Match(String, String, RegexOptions) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions) constructor and calling the instance Match(String) method.

Le paramètre pattern se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez .NET Framework des expressions régulières et le langage des expressions régulières-aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété Success de l’objet Match retourné.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Si une correspondance est trouvée, la propriété Value de l’objet Match retourné contient la sous-chaîne de input qui correspond au modèle d’expression régulière.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.If no match is found, its value is String.Empty.

Cette méthode retourne la première sous-chaîne trouvée dans input qui correspond au modèle d’expression régulière.This method returns the first substring found in input that matches the regular expression pattern. Vous pouvez récupérer les correspondances suivantes en appelant de façon répétée la méthode NextMatch de l’objet Match retourné.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String, String, RegexOptions).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération de correspondance dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notes pour les appelants

Cette méthode expire après un intervalle qui est égal à la valeur du délai d’attente par défaut du domaine d’application dans lequel elle est appelée.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche l’expiration du délai d’attente de la méthode, est utilisée.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. La méthode statique recommandée pour récupérer une correspondance de modèle est Match(String, String), qui vous permet de définir l’intervalle de délai d’attente.The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

Voir aussi

Match(String, Int32)

Recherche dans la chaîne d'entrée la première occurrence d'une expression régulière, en commençant à la position de départ spécifiée dans la chaîne.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);
public System.Text.RegularExpressions.Match Match (string input, int startat);
member this.Match : string * int -> System.Text.RegularExpressions.Match
Public Function Match (input As String, startat As Integer) As Match

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.The string to search for a match.

startat
Int32

Position du caractère de base zéro à partir duquel commencer la recherche.The zero-based character position at which to start the search.

Retours

Objet qui contient des informations sur la correspondance.An object that contains information about the match.

Exceptions

input a la valeur null.input is null.

startat est inférieur à zéro ou supérieur à la longueur de input.startat is less than zero or greater than the length of input.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Remarques

La méthode Match(String, Int32) retourne la première sous-chaîne qui correspond à un modèle d’expression régulière, en commençant à ou après la position du caractère startat, dans une chaîne d’entrée.The Match(String, Int32) method returns the first substring that matches a regular expression pattern, starting at or after the startat character position, in an input string. Pour plus d’informations sur les éléments de langage utilisés pour générer un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Le modèle d’expression régulière pour lequel la méthode Match(String, Int32) recherche est défini par l’appel à l’un des constructeurs de classe Regex.The regular expression pattern for which the Match(String, Int32) method searches is defined by the call to one of the Regex class constructors. Pour plus d’informations sur les éléments qui peuvent former un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Vous pouvez éventuellement spécifier une position de départ dans la chaîne à l’aide du paramètre startat.You can optionally specify a starting position in the string by using the startat parameter. Lorsque le moteur d’expression régulière analyse de gauche à droite (valeur par défaut), la correspondance et l’analyse se déplacent angle, en commençant au caractère spécifié dans startat.When the regular expression engine parses from left to right (the default), the match and the scan move rightward, starting at the character specified in startat. Lorsque le moteur d’expression régulière analyse de droite à gauche (lorsque le modèle d’expression régulière est construit avec l’option RegexOptions.RightToLeft), la correspondance et l’analyse se déplacent dans la direction opposée et commencent par le caractère à startat-1.When the regular expression engine parses from right to left (when the regular expression pattern is constructed with the RegexOptions.RightToLeft option), the match and scan move in the opposite direction and begin with the character at startat -1. Si vous ne spécifiez pas de position de départ, la recherche commence à la position par défaut startat.If you do not specify a starting position, the search begins at the default startat position. Si l’expression régulière recherche de gauche à droite, la position startat par défaut se trouve à l’extrémité gauche de input; Si la recherche s’effectue de droite à gauche, la position de startat par défaut se trouve à l’extrémité droite de input.If the regular expression searches from left to right, the default startat position is at the left end of input; if it searches from right to left, the default startat position is at the right end of input.

Si vous souhaitez limiter une correspondance de sorte qu’elle commence à une position de caractère particulière dans la chaîne et que le moteur des expressions régulières n’analyse pas le reste de la chaîne pour rechercher une correspondance, ancrez l’expression régulière avec un \G (à gauche pour un modèle de gauche à droite ou à droite pour un modèle de droite à gauche).If you want to restrict a match so that it begins at a particular character position in the string and the regular expression engine does not scan the remainder of the string for a match, anchor the regular expression with a \G (at the left for a left-to-right pattern, or at the right for a right-to-left pattern). Cela limite la correspondance afin qu’elle doive démarrer exactement à startat.This restricts the match so it must start exactly at startat.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété Success de l’objet Match retourné.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Si une correspondance est trouvée, la propriété Value de l’objet Match retourné contient la sous-chaîne de input qui correspond au modèle d’expression régulière.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.If no match is found, its value is String.Empty.

Cette méthode retourne la première sous-chaîne trouvée au startat position de caractère dans input qui correspond au modèle d’expression régulière.This method returns the first substring found at or after the startat character position in input that matches the regular expression pattern. Vous pouvez récupérer les correspondances suivantes en appelant de façon répétée la méthode Match.NextMatch de l’objet Match retourné.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String, Int32).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, Int32) method.

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération de correspondance dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse la valeur de délai d’attente définie pour le domaine d’application dans lequel l’objet Regex est créé.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si aucun délai d’attente n’est défini dans l’appel de constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Voir aussi

Match(String)

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée dans le constructeur Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);
public System.Text.RegularExpressions.Match Match (string input);
member this.Match : string -> System.Text.RegularExpressions.Match
Public Function Match (input As String) As Match

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.The string to search for a match.

Retours

Objet qui contient des informations sur la correspondance.An object that contains information about the match.

Exceptions

input a la valeur null.input is null.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Exemples

L’exemple suivant recherche des correspondances de modèle d’expression régulière dans une chaîne, puis répertorie les positions de groupes, de captures et de captures mises en correspondance.The following example finds regular expression pattern matches in a string, then lists the matched groups, captures, and capture positions.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21
using System;
using System.Text.RegularExpressions;

class Example 
{
   static void Main() 
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);
      
      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success) 
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++) 
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++) 
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

Le modèle d’expression régulière (\w+)\s+(car) correspond aux occurrences du mot « car » et du mot qui le précède.The regular expression pattern (\w+)\s+(car) matches occurrences of the word "car" along with the word that precedes it. Elle est interprétée comme indiqué dans le tableau suivant.It is interpreted as shown in the following table.

MotifPattern DescriptionDescription
(\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+ Correspond à un ou plusieurs espaces blancs.Match one or more white-space characters.
mensuel(car) Correspond à la chaîne littérale « car ».Match the literal string "car". Il s'agit du deuxième groupe de capture.This is the second capturing group.

Remarques

La méthode Match(String) retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée.The Match(String) method returns the first substring that matches a regular expression pattern in an input string. Pour plus d’informations sur les éléments de langage utilisés pour générer un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété Success de l’objet Match retourné.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Si une correspondance est trouvée, la propriété Value de l’objet Match retourné contient la sous-chaîne de input qui correspond au modèle d’expression régulière.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.If no match is found, its value is String.Empty.

Cette méthode retourne la première sous-chaîne dans input qui correspond au modèle d’expression régulière.This method returns the first substring in input that matches the regular expression pattern. Vous pouvez récupérer les correspondances suivantes en appelant de façon répétée la méthode Match.NextMatch de l’objet Match retourné.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String).You can also retrieve all matches in a single method call by calling the Regex.Matches(String) method.

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération de correspondance dépasse l’intervalle de délai d’attente spécifié par le constructeur Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. Si vous ne définissez pas d’intervalle de délai d’attente lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse la valeur de délai d’attente définie pour le domaine d’application dans lequel l’objet Regex est créé.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Si aucun délai d’attente n’est défini dans l’appel de constructeur Regex ou dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Voir aussi

Match(String, String)

Recherche dans la chaîne d'entrée spécifiée la première occurrence de l'expression régulière spécifiée.Searches the specified input string for the first occurrence of the specified regular expression.

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);
public static System.Text.RegularExpressions.Match Match (string input, string pattern);
static member Match : string * string -> System.Text.RegularExpressions.Match
Public Shared Function Match (input As String, pattern As String) As Match

Paramètres

input
String

Chaîne dans laquelle une correspondance doit être recherchée.The string to search for a match.

pattern
String

Modèle d’expression régulière à mettre en correspondance.The regular expression pattern to match.

Retours

Objet qui contient des informations sur la correspondance.An object that contains information about the match.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.A regular expression parsing error occurred.

input ou pattern est null.input or pattern is null.

Un délai d’attente a expiré.A time-out occurred. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.For more information about time-outs, see the Remarks section.

Exemples

L’exemple suivant appelle la méthode Match(String, String) pour rechercher le premier mot qui contient au moins un caractère z, puis appelle la méthode Match.NextMatch pour rechercher des correspondances supplémentaires.The following example calls the Match(String, String) method to find the first word that contains at least one z character, and then calls the Match.NextMatch method to find any additional matches.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "ablaze beagle choral dozen elementary fanatic " +
                     "glaze hunger inept jazz kitchen lemon minus " +
                     "night optical pizza quiz restoration stamina " +
                     "train unrest vertical whiz xray yellow zealous";
      string pattern = @"\b\w*z+\w*\b";
      Match m = Regex.Match(input, pattern);
      while (m.Success) {
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
         m = m.NextMatch();
      }   
   }
}
// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

Le modèle d'expression régulière \b\w*z+\w*\b est interprété comme indiqué dans le tableau suivant.The regular expression pattern \b\w*z+\w*\b is interpreted 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* Correspond à zéro, un ou plusieurs caractères alphabétiques.Match zero, one, or more word characters.
z+ Mettre en correspondance un ou plusieurs occurrences de la z caractère.Match one or more occurrences of the z character.
\w* Correspond à zéro, un ou plusieurs caractères alphabétiques.Match zero, one, or more word characters.
\b Terminer la correspondance à la limite d'un mot.End the match at a word boundary.

Remarques

La méthode Match(String, String) retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée.The Match(String, String) method returns the first substring that matches a regular expression pattern in an input string. Pour plus d’informations sur les éléments de langage utilisés pour générer un modèle d’expression régulière, consultez langage des expressions régulières-aide-mémoire.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

La méthode Match(String, String) statique est équivalente à la construction d’un objet Regex avec le modèle d’expression régulière spécifié et à l’appel de la méthode Match(String) de l’instance.The static Match(String, String) method is equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance Match(String) method. Dans ce cas, le moteur d’expression régulière met en cache le modèle d’expression régulière.In this case, the regular expression engine caches the regular expression pattern.

Le paramètre pattern se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à faire correspondre.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Pour plus d’informations sur les expressions régulières, consultez .NET Framework des expressions régulières et le langage des expressions régulières-aide-mémoire.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

Vous pouvez déterminer si le modèle d’expression régulière a été trouvé dans la chaîne d’entrée en vérifiant la valeur de la propriété Success de l’objet Match retourné.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Si une correspondance est trouvée, la propriété Value de l’objet Match retourné contient la sous-chaîne de input qui correspond au modèle d’expression régulière.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.If no match is found, its value is String.Empty.

Cette méthode retourne la première sous-chaîne dans input qui correspond au modèle d’expression régulière.This method returns the first substring in input that matches the regular expression pattern. Vous pouvez récupérer les correspondances suivantes en appelant de façon répétée la méthode Match.NextMatch de l’objet Match retourné.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String, String).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String) method.

L’exception RegexMatchTimeoutException est levée si la durée d’exécution de l’opération de correspondance dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application, ou si la valeur du délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notes pour les appelants

Cette méthode expire après un intervalle qui est égal à la valeur du délai d’attente par défaut du domaine d’application dans lequel elle est appelée.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. Si aucune valeur de délai d’attente n’a été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, ce qui empêche l’expiration du délai d’attente de la méthode, est utilisée.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. La méthode statique recommandée pour récupérer une correspondance de modèle est Match(String, String), qui vous permet de définir l’intervalle de délai d’attente.The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

Voir aussi

S’applique à