Match Classe

Définition

Représente les résultats d'une correspondance d'expression régulière unique.Represents the results from a single regular expression match.

public ref class Match : System::Text::RegularExpressions::Group
public class Match : System.Text.RegularExpressions.Group
[System.Serializable]
public class Match : System.Text.RegularExpressions.Group
type Match = class
    inherit Group
Public Class Match
Inherits Group
Héritage
Attributs

Exemples

Les exemples suivants utilisent l’expression régulière Console\.Write(Line)?.The following examples use the regular expression Console\.Write(Line)?. L'expression régulière est interprétée comme suit :The regular expression is interpreted as follows:

\de la console. EcrireConsole\.Write Mettre en correspondance la chaîne « Console.Write ».Match the string "Console.Write". Notez que le caractère « . » est placé dans une séquence d’échappement afin qu’il soit interprété comme un point littéral plutôt que comme un caractère générique qui correspond à n’importe quel caractère.Note that the "." character is escaped so that it is interpreted as a literal period rather than as a wildcard that matches any character.
(Ligne) ?(Line)? Mettre en correspondance zéro ou une occurrence de la chaîne « Line ».Match zero or one occurrence of the string "Line".

Exemple 1Example 1

L’exemple suivant appelle la méthode Regex.Matches(String, String) pour récupérer toutes les correspondances de modèle dans une chaîne d’entrée.The following example calls the Regex.Matches(String, String) method to retrieve all pattern matches in an input string. Il itère ensuite les objets Match dans l’objet MatchCollection retourné pour afficher des informations sur chaque correspondance.It then iterates the Match objects in the returned MatchCollection object to display information about each match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "int[] values = { 1, 2, 3 };\n" +
                     "for (int ctr = values.GetLowerBound(1); ctr <= values.GetUpperBound(1); ctr++)\n" +
                     "{\n" +
                     "   Console.Write(values[ctr]);\n" +
                     "   if (ctr < values.GetUpperBound(1))\n" +
                     "      Console.Write(\", \");\n" +
                     "}\n" +
                     "Console.WriteLine();\n";   
      
      string pattern = @"Console\.Write(Line)?";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine("'{0}' found in the source code at position {1}.",  
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//    'Console.Write' found in the source code at position 115.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 211.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Dim values() As Integer = { 1, 2, 3 }" & vbCrLf & _
                            "For ctr As Integer = values.GetLowerBound(1) To values.GetUpperBound(1)" & vbCrLf & _
                            "   Console.Write(values(ctr))" & vbCrLf & _
                            "   If ctr < values.GetUpperBound(1) Then Console.Write("", "")" & vbCrLf & _
                            "Next" & vbCrLf & _
                            "Console.WriteLine()"   
      Dim pattern As String = "Console\.Write(Line)?"
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine("'{0}' found in the source code at position {1}.", _ 
                           match.Value, match.Index)       
      Next                            
   End Sub
End Module
' The example displays the following output:
'    'Console.Write' found in the source code at position 115.
'    'Console.Write' found in the source code at position 184.
'    'Console.WriteLine' found in the source code at position 211.

Exemple 2Example 2

L’exemple suivant appelle les méthodes Match(String, String) et NextMatch pour récupérer une correspondance à la fois.The following example calls the Match(String, String) and NextMatch methods to retrieve one match at a time.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "int[] values = { 1, 2, 3 };\n" +
                     "for (int ctr = values.GetLowerBound(1); ctr <= values.GetUpperBound(1); ctr++)\n" +
                     "{\n" +
                     "   Console.Write(values[ctr]);\n" +
                     "   if (ctr < values.GetUpperBound(1))\n" +
                     "      Console.Write(\", \");\n" +
                     "}\n" +
                     "Console.WriteLine();\n";   
      string pattern = @"Console\.Write(Line)?";
      Match match = Regex.Match(input, pattern);
      while (match.Success)
      {
         Console.WriteLine("'{0}' found in the source code at position {1}.",  
                           match.Value, match.Index);
         match = match.NextMatch();
      }
   }
}
// The example displays the following output:
//    'Console.Write' found in the source code at position 115.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 211.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Dim values() As Integer = { 1, 2, 3 }" & vbCrLf & _
                            "For ctr As Integer = values.GetLowerBound(1) To values.GetUpperBound(1)" & vbCrLf & _
                            "   Console.Write(values(ctr))" & vbCrLf & _
                            "   If ctr < values.GetUpperBound(1) Then Console.Write("", "")" & vbCrLf & _
                            "Next" & vbCrLf & _
                            "Console.WriteLine()"   
      Dim pattern As String = "Console\.Write(Line)?"
      Dim match As Match = Regex.Match(input, pattern)
      Do While match.Success
         Console.WriteLine("'{0}' found in the source code at position {1}.", _ 
                           match.Value, match.Index)
         match = match.NextMatch()                  
      Loop                            
   End Sub
End Module
' The example displays the following output:
'    'Console.Write' found in the source code at position 115.
'    'Console.Write' found in the source code at position 184.
'    'Console.WriteLine' found in the source code at position 211.

Remarques

L’objet Match est immuable et n’a pas de constructeur public.The Match object is immutable and has no public constructor. Une instance de la classe Match est retournée par la méthode Regex.Match et représente la première correspondance de modèle dans une chaîne.An instance of the Match class is returned by the Regex.Match method and represents the first pattern match in a string. Les correspondances suivantes sont représentées par Match objets retournés par la méthode Match.NextMatch.Subsequent matches are represented by Match objects returned by the Match.NextMatch method. En outre, un objet MatchCollection qui se compose de zéro, un ou plusieurs objets Match est retourné par la méthode Regex.Matches.In addition, a MatchCollection object that consists of zero, one, or more Match objects is returned by the Regex.Matches method.

Si la méthode Regex.Matches ne parvient pas à faire correspondre un modèle d’expression régulière dans une chaîne d’entrée, elle retourne un objet MatchCollection vide.If the Regex.Matches method fails to match a regular expression pattern in an input string, it returns an empty MatchCollection object. Vous pouvez ensuite utiliser une construction foreach dans C# ou une construction For Each dans Visual Basic pour itérer la collection.You can then use a foreach construct in C# or a For Each construct in Visual Basic to iterate the collection.

Si la méthode Regex.Match ne correspond pas au modèle d’expression régulière, elle retourne un objet Match qui est égal à Match.Empty.If the Regex.Match method fails to match the regular expression pattern, it returns a Match object that is equal to Match.Empty. Vous pouvez utiliser la propriété Success pour déterminer si la correspondance a réussi.You can use the Success property to determine whether the match was successful. L'exemple suivant en est l'illustration.The following example provides an illustration.

// Search for a pattern that is not found in the input string.
string pattern = "dog";
string input = "The cat saw the other cats playing in the back yard.";
Match match = Regex.Match(input, pattern);
if (match.Success )
   // Report position as a one-based integer.
   Console.WriteLine("'{0}' was found at position {1} in '{2}'.", 
                     match.Value, match.Index + 1, input);
else
   Console.WriteLine("The pattern '{0}' was not found in '{1}'.",
                     pattern, input);
' Search for a pattern that is not found in the input string.
Dim pattern As String = "dog"
Dim input As String = "The cat saw the other cats playing in the back yard."
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
   ' Report position as a one-based integer.
   Console.WriteLine("'{0}' was found at position {1} in '{2}'.", _ 
                     match.Value, match.Index + 1, input)
Else
   Console.WriteLine("The pattern '{0}' was not found in '{1}'.", _
                     pattern, input)
End If

Si une correspondance de modèle réussit, la propriété Value contient la sous-chaîne mise en correspondance, la propriété Index indique la position de départ de base zéro de la sous-chaîne mise en correspondance dans la chaîne d’entrée, et la propriété Length indique la longueur de la sous-chaîne mise en correspondance dans la chaîne d’entrée.If a pattern match is successful, the Value property contains the matched substring, the Index property indicates the zero-based starting position of the matched substring in the input string, and the Length property indicates the length of matched substring in the input string.

Étant donné qu’une correspondance unique peut impliquer plusieurs groupes de capture, Match a une propriété Groups qui retourne le GroupCollection.Because a single match can involve multiple capturing groups, Match has a Groups property that returns the GroupCollection. L’instance de Match elle-même est équivalente au premier objet de la collection, à Match.Groups[0] (Match.Groups(0) dans Visual Basic), qui représente la correspondance entière.The Match instance itself is equivalent to the first object in the collection, at Match.Groups[0] (Match.Groups(0) in Visual Basic), which represents the entire match. Vous pouvez accéder aux groupes capturés dans une correspondance des manières suivantes :You can access the captured groups in a match in the following ways:

  • Vous pouvez itérer les membres de l’objet GroupCollection à l’aide d’uneC#construction foreach () ou For Each (Visual Basic).You can iterate the members of the GroupCollection object by using a foreach (C#) or For Each (Visual Basic) construct.

  • Vous pouvez utiliser la propriété GroupCollection.Item[Int32] pour récupérer des groupes en utilisant le numéro du groupe de capture.You can use the GroupCollection.Item[Int32] property to retrieve groups by the number of the capturing group. Notez que vous pouvez déterminer les groupes numérotés présents dans une expression régulière en appelant la méthode Regex.GetGroupNumbers de l’instance.Note that you can determine which numbered groups are present in a regular expression by calling the instance Regex.GetGroupNumbers method.

  • Vous pouvez utiliser la propriété GroupCollection.Item[String] pour récupérer des groupes en utilisant le nom du groupe de capture.You can use the GroupCollection.Item[String] property to retrieve groups by the name of the capturing group. Notez que vous pouvez déterminer les groupes nommés présents dans une expression régulière en appelant la méthode Regex.GetGroupNames() de l’instance.Note that you can determine which named groups are present in a regular expression by calling the instance Regex.GetGroupNames() method.

Propriétés

Captures

Obtient une collection de toutes les captures correspondant au groupe de capture, dans l'ordre du plus profond et du plus à gauche (ou dans l'ordre du plus profond et du plus à droite, si l'expression régulière est modifiée par l'option RightToLeft).Gets a collection of all the captures matched by the capturing group, in innermost-leftmost-first order (or innermost-rightmost-first order if the regular expression is modified with the RightToLeft option). La collection peut contenir entre zéro et plusieurs éléments.The collection may have zero or more items.

(Hérité de Group)
Empty

Obtient le groupe vide.Gets the empty group. Toutes les correspondances infructueuses retournent cette correspondance vide.All failed matches return this empty match.

Groups

Obtient une collection de groupes correspondant à l’expression régulière.Gets a collection of groups matched by the regular expression.

Index

Position dans la chaîne d'origine où se trouve le premier caractère de la sous-chaîne capturée.The position in the original string where the first character of the captured substring is found.

(Hérité de Capture)
Length

Obtient la longueur de la sous-chaîne capturée.Gets the length of the captured substring.

(Hérité de Capture)
Name

Retourne le nom du groupe de capture représenté par l’instance actuelle.Returns the name of the capturing group represented by the current instance.

(Hérité de Group)
Success

Obtient une valeur indiquant si la correspondance est réussie.Gets a value indicating whether the match is successful.

(Hérité de Group)
Value

Obtient la sous-chaîne capturée à partir de la chaîne d'entrée.Gets the captured substring from the input string.

(Hérité de Capture)

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
NextMatch()

Retourne un nouvel objet Match avec les résultats de la correspondance suivante, en commençant à la position à laquelle la dernière correspondance s'est terminée (au niveau du caractère qui se trouve après le dernier caractère correspondant).Returns a new Match object with the results for the next match, starting at the position at which the last match ended (at the character after the last matched character).

Result(String)

Retourne le déploiement du motif de remplacement spécifié.Returns the expansion of the specified replacement pattern.

Synchronized(Match)

Retourne une instance de Match équivalant à celle qui est fournie, dont le partage entre plusieurs threads est possible.Returns a Match instance equivalent to the one supplied that is suitable to share between multiple threads.

ToString()

Récupère la sous-chaîne capturée de la chaîne d'entrée en appelant la propriété Value.Retrieves the captured substring from the input string by calling the Value property.

(Hérité de Capture)

S’applique à

Voir aussi