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.

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.

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.

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.

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.

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.

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.

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.

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.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

matchTimeout
TimeSpan

Intervalle de délai d’attente ou InfiniteMatchTimeout pour indiquer que la méthode ne doit pas expirer.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

input ou pattern est null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

  • ou - matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

La Match(String, String, RegexOptions, TimeSpan) méthode retourne le premier sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La méthode statique Match(String, String, RegexOptions, TimeSpan) équivaut à construire un Regex objet avec le Regex(String, RegexOptions, TimeSpan) constructeur et à appeler la méthode d’instance Match(String) .

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à correspondre. Pour plus d’informations sur les expressions régulières, consultez .NET 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é de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de l’objet retourné Match contient la sous-chaîne à partir de input laquelle correspond le modèle d’expression Value régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

Cette méthode retourne la première sous-chaîne trouvée dans input laquelle correspond le modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de NextMatch l’objet retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un seul appel de méthode en appelant la Regex.Matches(String, String, RegexOptions) méthode.

Le matchTimeout paramètre spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer de trouver une correspondance avant son expiration. La définition d’un intervalle de délai d’attente empêche les expressions régulières qui s’appuient sur un retour arrière excessif d’apparaître pour cesser de répondre lorsqu’elles traitent les entrées qui contiennent des correspondances proches. Pour plus d’informations, consultez Meilleures pratiques pour les expressions régulières et le retour arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une RegexMatchTimeoutException exception. matchTimeout remplace toute valeur de délai d’expiration par défaut définie pour le domaine d’application dans lequel la méthode s’exécute.

Notes pour les appelants

Nous vous recommandons de définir le matchTimeout paramètre sur une valeur appropriée, par exemple deux secondes. 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. Toutefois, vous devez désactiver les délais d’attente uniquement dans les conditions suivantes :

  • 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 de texte statique. Cela exclut le texte qui a été entré dynamiquement par les utilisateurs.

  • Lorsque le modèle d’expression régulière a été soigneusement testé pour s’assurer qu’il gère efficacement les correspondances, les non-correspondances et les correspondances proches.

  • Lorsque le modèle d’expression régulière ne contient aucun élément de langage connu pour provoquer un retour arrière excessif lors du traitement d’une correspondance proche.

Voir aussi

S’applique à

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.

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.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

input a la valeur null.

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant recherche des correspondances de modèle d’expression régulière dans une chaîne, puis répertorie les groupes, captures et positions de capture correspondants.

#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 (\w+)\s+(car) d’expression régulière correspond aux occurrences du mot « car » ainsi que le mot qui l’précède. Il est interprété comme indiqué dans le tableau suivant.

Modèle Description
(\w+) Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du premier groupe de capture.
\s+ Mettre en correspondance un ou plusieurs caractères d’espace blanc.
(voiture) Mettre en correspondance la chaîne littérale « car ». Il s'agit du deuxième groupe de capture.

Remarques

La Match(String) méthode retourne le premier sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

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é de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de l’objet Value retourné Match contient la sous-chaîne à partir de input laquelle correspond le modèle d’expression régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

Cette méthode retourne la première sous-chaîne qui input correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de l’objet Match.NextMatch retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un seul appel de méthode en appelant la Regex.Matches(String) méthode.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur. 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 toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du Regex constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est , aucune exception n’est Regex.InfiniteMatchTimeoutlevée.

Voir aussi

S’applique à

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.

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.

startat
Int32

Position du caractère de base zéro à partir duquel commencer la recherche.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

input a la valeur null.

startat est inférieur à zéro ou supérieur à la longueur de input.

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

La Match(String, Int32) méthode 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 startat caractère, dans une chaîne d’entrée. Modèle d’expression régulière pour lequel la Match(String, Int32) méthode recherche est définie par l’appel à l’un des constructeurs de Regex classe. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

Paramètre startat

Vous pouvez éventuellement spécifier une position de départ dans la chaîne à l’aide du startat paramètre. Toutes les correspondances commençant avant startat la chaîne sont ignorées. Si vous ne spécifiez pas de position de départ, la recherche commence à la position par défaut, qui est la fin gauche d’une input recherche de gauche à droite et la fin droite d’une recherche de input droite à gauche. Malgré le début à startat, l’index d’une correspondance retournée est relatif au début de la chaîne.

Bien que le moteur d’expression régulière ne retourne aucune correspondance avant startat, il n’ignore pas la chaîne avant startat. Cela signifie que les assertions telles que les ancres ou les assertions lookbehind s’appliquent toujours à l’entrée dans son ensemble. Par exemple, le code suivant inclut un modèle avec une assertion lookbehind qui est satisfaite même si elle se produit avant l’index startat de 5 dans la chaîne d’entrée.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example3
    {
        public static void Main()
        {
            string input = "Zip code: 98052";
            var regex = new Regex(@"(?<=Zip code: )\d{5}");
            Match match = regex.Match(input, 5);
            if (match.Success)
                Console.WriteLine("Match found: {0}", match.Value);
        }
    }
}

// This code prints the following output:
// Match found: 98052

Conseil

  • Si un modèle commence par l’ancre ^ mais startat est supérieur à 0, aucune correspondance n’est jamais trouvée dans une recherche à une seule ligne, car elles sont limitées par ^ le démarrage à l’index 0.
  • L’ancre\G est satisfaite à startat. Pour cette raison, si vous souhaitez restreindre une correspondance afin qu’elle commence exactement à une position de caractère particulière dans la chaîne, ancrez l’expression régulière avec un \G modèle de gauche à droite. Cela limite la correspondance afin qu’elle commence exactement startat à (ou, lorsque plusieurs correspondances sont souhaitées, de sorte que les correspondances sont contiguës).

Recherches de droite à gauche

Une recherche de droite à gauche, c’est-à-dire, lorsque le modèle d’expression régulière est construit avec l’option RegexOptions.RightToLeft , se comporte de la manière suivante :

  • L’analyse se déplace dans la direction opposée et le modèle est mis en correspondance de l’arrière (de droite) à l’avant (gauche).
  • La position de départ par défaut est la fin droite de la chaîne d’entrée.
  • Si startat elle est spécifiée, l’analyse de droite à gauche commence au caractère à startat - 1 (pas startat).
  • Lorsque l’ancre \G est spécifiée à la fin droite d’un modèle, elle limite la correspondance (première) à se terminer exactement à startat - 1.

Pour plus d’informations sur les recherches de droite à gauche, consultez le mode De droite à gauche.

Déterminer si une correspondance est trouvée

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é de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de l’objet Value retourné Match contient la sous-chaîne à partir de input laquelle correspond le modèle d’expression régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

Première ou plusieurs correspondances

Cette méthode retourne la première sous-chaîne trouvée à ou après la position du startat caractère qui input correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de l’objet Match.NextMatch retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un seul appel de méthode en appelant la Regex.Matches(String, Int32) méthode.

Exceptions de délai d’attente

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur. 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 toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’attente n’est défini dans l’appel du Regex constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’attente est , aucune exception n’est Regex.InfiniteMatchTimeoutlevée.

Voir aussi

S’applique à

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.

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.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

input ou pattern est null.

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant appelle la Match(String, String) méthode pour rechercher le premier mot qui contient au moins un z caractère, puis appelle la Match.NextMatch méthode pour rechercher des correspondances supplémentaires.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    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.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
\w* Mettre en correspondance zéro, un ou plusieurs caractères de mot.
z+ Mettre en correspondance un ou plusieurs occurrences de la z caractère.
\w* Mettre en correspondance zéro, un ou plusieurs caractères de mot.
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Match(String, String) méthode retourne la première sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La méthode statique Match(String, String) équivaut à construire un Regex objet avec le modèle d’expression régulière spécifié et à appeler la méthode d’instance Match(String) . Dans ce cas, le moteur d’expression régulière met en cache le modèle d’expression régulière.

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à mettre en correspondance. Pour plus d’informations sur les expressions régulières, consultez .NET 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é de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de l’objet Value retourné Match contient la sous-chaîne à partir de input laquelle correspond le modèle d’expression régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

Cette méthode retourne la première sous-chaîne qui input correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de l’objet Match.NextMatch retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un seul appel de méthode en appelant la Regex.Matches(String, String) méthode.

L’exception RegexMatchTimeoutException est levée si le temps d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée. Si aucun délai d’attente n’est défini dans les propriétés du domaine d’application ou si la valeur de délai d’attente est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est appelée. Si une valeur de délai d’expiration n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode de minutage, est utilisée. La méthode statique recommandée pour la récupération d’une correspondance de modèle est Match(String, String), ce qui vous permet de définir l’intervalle de délai d’expiration.

Voir aussi

S’applique à

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.

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.

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.

length
Int32

Nombre de caractères dans la sous-chaîne à inclure dans la recherche.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

input a la valeur null.

beginning est inférieur à zéro ou supérieur à la longueur de input.

  • ou - length est inférieur à zéro ou supérieur à la longueur de input.

  • ou - beginning+length-1 identifie un emplacement situé en dehors de la plage de input.

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Remarques

La Match(String, Int32, Int32) méthode retourne le premier sous-chaîne qui correspond à un modèle d’expression régulière dans une partie d’une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

Modèle d’expression régulière pour lequel la Match(String, Int32, Int32) méthode recherche est définie par l’appel à l’un des constructeurs de Regex classes. Pour plus d’informations sur les éléments qui peuvent former un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La Match(String, Int32, Int32) méthode recherche la partie définie input par les paramètres et length le beginning modèle d’expression régulière. 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. Ensemble, ils définissent la plage de la recherche. Le comportement est exactement comme si le input était effectivement input.Substring(beginning, length), sauf que l’index d’une correspondance est compté par rapport au début de input. Cela signifie que toutes les ancres ou assertions de largeur nulle au début ou à la fin du modèle se comportent comme s’il n’y a pas input en dehors de cette plage. Par exemple, les ancres, et seront satisfaites ^et beginning $ \z seront satisfaites à beginning + length - 1.\A \G

Si la recherche passe de gauche à droite (la valeur par défaut), le moteur d’expression régulière recherche du caractère à l’index beginning vers le caractère à l’index beginning + length - 1. Si le moteur d’expression régulière a été instancié à l’aide de l’option RegexOptions.RightToLeft afin que la recherche passe de droite à gauche, le moteur d’expression régulière recherche du caractère à l’index vers le caractère à l’index beginning + length - 1 beginning.

Cette méthode retourne la première correspondance qu’elle trouve dans cette plage. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de Match.NextMatch l’objet retournéMatch.

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é de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de l’objet retourné Match contient la sous-chaîne à partir de input laquelle correspond le modèle d’expression Value régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

L’exception RegexMatchTimeoutException est levée si l’heure d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié par le Regex.Regex(String, RegexOptions, TimeSpan) constructeur. Si vous ne définissez pas de valeur de délai d’expiration lorsque vous appelez le constructeur, l’exception est levée si l’opération dépasse toute valeur de délai d’attente établie pour le domaine d’application dans lequel l’objet Regex est créé. Si aucun délai d’expiration n’est défini dans l’appel Regex du constructeur ou dans les propriétés du domaine d’application, ou si la valeur de délai d’expiration est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Voir aussi

S’applique à

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.

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.

pattern
String

Modèle d’expression régulière à mettre en correspondance.

options
RegexOptions

Combinaison d'opérations de bits des valeurs d'énumération qui fournissent des options pour la correspondance.

Retours

Match

Objet qui contient des informations sur la correspondance.

Exceptions

Une erreur d’analyse d’expression régulière s’est produite.

input ou pattern est null.

options n’est pas une combinaison d’opérations au niveau du bit de valeurs RegexOptions.

Un délai d’attente a expiré. Pour plus d’informations sur les dépassements de délai d’attente, consultez la section Notes.

Exemples

L’exemple suivant définit une expression régulière qui correspond aux mots commençant par la lettre « a ». Il utilise l’option RegexOptions.IgnoreCase pour s’assurer que l’expression régulière recherche les mots commençant par une majuscule « a » et une minuscule « a ».

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        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.

Modèle Description
\b Commencer la correspondance à la limite d'un mot.
a Correspond au caractère « a ».
\w* Correspond à zéro, un ou plusieurs caractères de mot.
\b Terminer la correspondance à la limite d'un mot.

Remarques

La Match(String, String, RegexOptions) méthode retourne le premier sous-chaîne qui correspond à un modèle d’expression régulière dans une chaîne d’entrée. Pour plus d’informations sur les éléments de langage utilisés pour créer un modèle d’expression régulière, consultez Langage d’expression régulière - Référence rapide.

La méthode statique Match(String, String, RegexOptions) équivaut à construire un Regex objet avec le Regex(String, RegexOptions) constructeur et à appeler la méthode d’instance Match(String) .

Le pattern paramètre se compose d’éléments de langage d’expression régulière qui décrivent symboliquement la chaîne à correspondre. Pour plus d’informations sur les expressions régulières, consultez .NET 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é de Success l’objet retournéMatch. Si une correspondance est trouvée, la propriété de l’objet retourné Match contient la sous-chaîne à partir de input laquelle correspond le modèle d’expression Value régulière. Si aucune correspondance n’est trouvée, sa valeur est String.Empty.

Cette méthode retourne la première sous-chaîne trouvée dans input laquelle correspond le modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode de NextMatch l’objet retournéMatch. Vous pouvez également récupérer toutes les correspondances dans un seul appel de méthode en appelant la Regex.Matches(String, String, RegexOptions) méthode.

L’exception RegexMatchTimeoutException est levée si l’heure d’exécution de l’opération correspondante dépasse l’intervalle de délai d’attente spécifié pour le domaine d’application dans lequel la méthode est appelée. Si aucun délai d’expiration n’est défini dans les propriétés du domaine d’application, ou si la valeur de délai d’expiration est Regex.InfiniteMatchTimeout, aucune exception n’est levée.

Notes pour les appelants

Cette méthode expire après un intervalle égal à la valeur de délai d’expiration par défaut du domaine d’application dans lequel elle est appelée. Si une valeur de délai d’expiration n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode de minutage, est utilisée. La méthode statique recommandée pour la récupération d’une correspondance de modèle est Match(String, String), ce qui vous permet de définir l’intervalle de délai d’expiration.

Voir aussi

S’applique à