Match Classe

Definição

Representa os resultados de correspondência de uma única expressão regular.Represents the results from a single regular expression match.

public ref 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
Herança
Atributos

Exemplos

Os exemplos a seguir usam a expressão regular Console\.Write(Line)?.The following examples use the regular expression Console\.Write(Line)?. A expressão regular é interpretada da seguinte forma:The regular expression is interpreted as follows:

\do console. GraváConsole\.Write Corresponder à cadeia de caracteres “Console.Write”.Match the string "Console.Write". Observe que o caractere "." é ignorado para que seja interpretado como um período literal, e não como um curinga que corresponda a qualquer caractere.Note that the "." character is escaped so that it is interpreted as a literal period rather than as a wildcard that matches any character.
(Linha)?(Line)? Corresponde a zero ou uma ocorrência da cadeia de caracteres “Line”.Match zero or one occurrence of the string "Line".

Exemplo 1Example 1

O exemplo a seguir chama o método Regex.Matches(String, String) para recuperar todas as correspondências de padrão em uma cadeia de caracteres de entrada.The following example calls the Regex.Matches(String, String) method to retrieve all pattern matches in an input string. Em seguida, ele itera os objetos Match no objeto de MatchCollection retornado para exibir informações sobre cada correspondência.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.

Exemplo 2Example 2

O exemplo a seguir chama os métodos Match(String, String) e NextMatch para recuperar uma correspondência de cada vez.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.

Comentários

O objeto Match é imutável e não tem nenhum construtor público.The Match object is immutable and has no public constructor. Uma instância da classe Match é retornada pelo método Regex.Match e representa a primeira correspondência de padrão em uma cadeia de caracteres.An instance of the Match class is returned by the Regex.Match method and represents the first pattern match in a string. As correspondências subsequentes são representadas por Match objetos retornados pelo método Match.NextMatch.Subsequent matches are represented by Match objects returned by the Match.NextMatch method. Além disso, um objeto MatchCollection que consiste em zero, um ou mais objetos Match é retornado pelo método Regex.Matches.In addition, a MatchCollection object that consists of zero, one, or more Match objects is returned by the Regex.Matches method.

Se o método Regex.Matches não corresponder a um padrão de expressão regular em uma cadeia de caracteres de entrada, ele retornará um objeto MatchCollection vazio.If the Regex.Matches method fails to match a regular expression pattern in an input string, it returns an empty MatchCollection object. Você pode usar uma construção foreach no C# ou uma construção For Each no Visual Basic para iterar a coleção.You can then use a foreach construct in C# or a For Each construct in Visual Basic to iterate the collection.

Se o método Regex.Match não corresponder ao padrão de expressão regular, ele retornará um objeto Match que seja igual a 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. Você pode usar a propriedade Success para determinar se a correspondência foi bem-sucedida.You can use the Success property to determine whether the match was successful. O exemplo a seguir fornece uma ilustração.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

Se uma correspondência de padrão for bem-sucedida, a propriedade Value contiver a subcadeia de caracteres correspondente, a propriedade Index indicará a posição inicial de base zero da subcadeia de caracteres correspondente na cadeia de caracteres de entrada e a propriedade Length indicará o comprimento da subcadeia de caracteres correspondente na cadeia de caracteres de entrada.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.

Como uma única correspondência pode envolver vários grupos de captura, Match tem uma propriedade Groups que retorna a GroupCollection.Because a single match can involve multiple capturing groups, Match has a Groups property that returns the GroupCollection. A própria instância de Match é equivalente ao primeiro objeto na coleção, em Match.Groups[0] (Match.Groups(0) em Visual Basic), que representa a correspondência inteira.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. Você pode acessar os grupos capturados de uma correspondência das seguintes maneiras:You can access the captured groups in a match in the following ways:

  • Você pode iterar os membros do objeto GroupCollection usando uma construção foreach (C#) 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.

  • Você pode usar a propriedade GroupCollection.Item[Int32] para recuperar grupos pelo número do grupo de captura.You can use the GroupCollection.Item[Int32] property to retrieve groups by the number of the capturing group. Observe que você pode determinar quais grupos numerados estão presentes em uma expressão regular chamando o método de Regex.GetGroupNumbers de instância.Note that you can determine which numbered groups are present in a regular expression by calling the instance Regex.GetGroupNumbers method.

  • Você pode usar a propriedade GroupCollection.Item[String] para recuperar grupos pelo nome do grupo de captura.You can use the GroupCollection.Item[String] property to retrieve groups by the name of the capturing group. Observe que você pode determinar quais grupos nomeados estão presentes em uma expressão regular chamando o método de Regex.GetGroupNames() de instância.Note that you can determine which named groups are present in a regular expression by calling the instance Regex.GetGroupNames() method.

Propriedades

Captures

Obtém uma coleção de todas as capturas correspondida pelo grupo de captura, na primeira ordem interna mais à esquerda (ou primeira ordem interna mais à direita se a expressão regular for modificada com a opção 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). A coleção pode ter zero ou mais itens.The collection may have zero or more items.

(Herdado de Group)
Empty

Obtém o grupo vazio.Gets the empty group. Todas as correspondências com falha retornam essa correspondência vazia.All failed matches return this empty match.

Groups

Obtém uma coleção de grupos correspondentes à expressão regular.Gets a collection of groups matched by the regular expression.

Index

A posição na cadeia de caracteres original em que foi encontrado o primeiro caractere da subcadeia capturada.The position in the original string where the first character of the captured substring is found.

(Herdado de Capture)
Length

Obtém o comprimento da subcadeia de caracteres capturada.Gets the length of the captured substring.

(Herdado de Capture)
Name

Retorna o nome do grupo de captura representado pela instância atual.Returns the name of the capturing group represented by the current instance.

(Herdado de Group)
Success

Obtém um valor que indica se a correspondência foi bem-sucedida.Gets a value indicating whether the match is successful.

(Herdado de Group)
Value

Obtém a subcadeia de caracteres capturada da cadeia de caracteres de entrada.Gets the captured substring from the input string.

(Herdado de Capture)

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
NextMatch()

Retorna um novo objeto Match com os resultados para a próxima correspondência, começando na posição em que a última correspondência terminou (no caractere após o último caractere correspondente).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)

Retorna a expansão do padrão de substituição especificado.Returns the expansion of the specified replacement pattern.

Synchronized(Match)

Retorna um instância Match equivalente a uma fornecida que é adequada para compartilhar entre vários threads.Returns a Match instance equivalent to the one supplied that is suitable to share between multiple threads.

ToString()

Recupera a subcadeia de caracteres capturada da cadeia de entrada chamando a propriedade Value.Retrieves the captured substring from the input string by calling the Value property.

(Herdado de Capture)

Aplica-se a

Veja também