Regex.Match Méthode

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

Objet qui contient des informations sur la correspondance.

Exceptions

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 d’expression régulière (\w+)\s+(car) 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.

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. 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 d’expression régulière - Informations de référence rapides.

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é. Si une correspondance est trouvée, la propriété Value de l’objet Match retournée contient la sous-chaîne de input qui correspond au 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 dans input qui correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode Match.NextMatch de l’objet Match retourné. Vous pouvez également récupérer toutes les correspondances dans un appel de méthode unique en appelant la méthode Regex.Matches(String).

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 constructeur Regex.Regex(String, RegexOptions, TimeSpan). 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 constructeur Regex ou 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.

Voir aussi

• NextMatch()
• langage d’expression régulière - de référence rapide

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

Objet qui contient des informations sur la correspondance.

Exceptions

Remarques

Pour plus d’informations sur cette API, consultez remarques sur l’API supplémentaire pour Regex.Match.

Voir aussi

• NextMatch()
• langage d’expression régulière - de référence rapide

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

Objet qui contient des informations sur la correspondance.

Exceptions

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.

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.

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. 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 d’expression régulière - Informations de référence rapides.

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

Le paramètre pattern 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 expressions régulières .NET et langage d’expression régulière - Informations de référence rapides.

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é. Si une correspondance est trouvée, la propriété Value de l’objet Match retournée contient la sous-chaîne de input qui correspond au 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 dans input qui correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode Match.NextMatch de l’objet Match retourné. 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).

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’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode d’expirer, est utilisée. La méthode statique recommandée pour récupérer une correspondance de modèle est Match(String, String), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

• NextMatch()
• langage d’expression régulière - de référence rapide

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

Objet qui contient des informations sur la correspondance.

Exceptions

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. 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 d’expression régulière - Informations de référence rapides.

Modèle d’expression régulière pour lequel les recherches de méthode Match(String, Int32, Int32) sont définies par l’appel à l’un des constructeurs de classe Regex. 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 - Informations de référence rapides.

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. 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’existe aucun input en dehors de cette plage. Par exemple, les ancres ^, \Get \A seront satisfaites à beginning et $ et \z seront satisfaites à beginning + length - 1.

Si la recherche passe de gauche à droite (valeur par défaut), le moteur d’expression régulière recherche du caractère à l’index beginning au 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 effectue des recherches du caractère à l’index beginning + length - 1 au caractère à l’index 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 Match.NextMatch de l’objet Match retourné.

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

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 constructeur Regex.Regex(String, RegexOptions, TimeSpan). 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 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 constructeur Regex ou 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.

Voir aussi

• NextMatch()
• langage d’expression régulière - de référence rapide

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

Objet qui contient des informations sur la correspondance.

Exceptions

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 un 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.

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. 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 d’expression régulière - Informations de référence rapides.

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

Le paramètre pattern 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 expressions régulières .NET et langage d’expression régulière - Informations de référence rapides.

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é. Si une correspondance est trouvée, la propriété Value de l’objet Match retournée contient la sous-chaîne de input qui correspond au 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 trouvée dans input qui correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode NextMatch de l’objet Match retourné. 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).

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’attente n’a pas été définie pour le domaine d’application, la valeur InfiniteMatchTimeout, qui empêche la méthode d’expirer, est utilisée. La méthode statique recommandée pour récupérer une correspondance de modèle est Match(String, String), ce qui vous permet de définir l’intervalle de délai d’attente.

Voir aussi

• NextMatch()
• langage d’expression régulière - de référence rapide

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

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

Retours

Objet qui contient des informations sur la correspondance.

Exceptions

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. 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 d’expression régulière - Informations de référence rapides.

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

Le paramètre pattern 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 expressions régulières .NET et langage d’expression régulière - Informations de référence rapides.

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é. Si une correspondance est trouvée, la propriété Value de l’objet Match retournée contient la sous-chaîne de input qui correspond au 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 trouvée dans input qui correspond au modèle d’expression régulière. Vous pouvez récupérer les correspondances suivantes en appelant à plusieurs reprises la méthode NextMatch de l’objet Match retourné. 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).

Le paramètre matchTimeout spécifie la durée pendant laquelle une méthode de correspondance de modèle doit essayer 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 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 retour arrière. Si aucune correspondance n’est trouvée dans cet intervalle de temps, la méthode lève une exception RegexMatchTimeoutException. 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.

Notes pour les appelants

Nous vous recommandons de définir le paramètre matchTimeout 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

• langage d’expression régulière - de référence rapide