Match Classe

Referência

Definição

Namespace:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa os resultados de correspondência de uma única expressão regular.

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

[<System.Serializable>]
type Match = class
    inherit Group

Public Class Match
Inherits Group

Herança: Object

Capture

Group
Match

Atributos: SerializableAttribute

Exemplos

Os exemplos a seguir usam a expressão Console\.Write(Line)?regular. A expressão regular é interpretada da seguinte forma:


Console\. Escrever	Corresponder à cadeia de caracteres “Console.Write”. Observe que o caractere "." é escapado para que ele seja interpretado como um período literal em vez de como um curinga que corresponde a qualquer caractere.
(Linha)?	Corresponde a zero ou uma ocorrência da cadeia de caracteres “Line”.

Exemplo 1

O exemplo a seguir chama o Regex.Matches(String, String) método para recuperar todas as correspondências de padrão em uma cadeia de caracteres de entrada. Em seguida, itera os Match objetos no objeto retornado MatchCollection para exibir informações sobre cada correspondência.

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 112.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 207.

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 2

O exemplo a seguir chama os métodos e NextMatch os Match(String, String) métodos para recuperar uma correspondência por vez.

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 112.
//    'Console.Write' found in the source code at position 184.
//    'Console.WriteLine' found in the source code at position 207.

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 Match objeto é imutável e não tem construtor público. Uma instância da Match classe é retornada pelo Regex.Match método e representa a primeira correspondência de padrão em uma cadeia de caracteres. As correspondências subsequentes são representadas por Match objetos retornados pelo Match.NextMatch método. Além disso, um MatchCollection objeto que consiste em zero, um ou mais Match objetos é retornado pelo Regex.Matches método.

Se o Regex.Matches método não corresponder a um padrão de expressão regular em uma cadeia de caracteres de entrada, ele retornará um objeto vazio MatchCollection . Em seguida, você pode usar um foreach constructo em C# ou um For Each constructo em Visual Basic para iterar a coleção.

Se o Regex.Match método não corresponder ao padrão de expressão regular, ele retornará um Match objeto igual a Match.Empty. Você pode usar a Success propriedade para determinar se a correspondência foi bem-sucedida. O exemplo a seguir ilustra esse cenário.

// 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 Value propriedade conterá a subcadeia de caracteres correspondente, a Index propriedade indicará a posição inicial baseada em zero da subcadeia de caracteres correspondente na cadeia de caracteres de entrada e a Length propriedade indicará o comprimento da subcadeia de caracteres correspondente na cadeia de caracteres de entrada.

Como uma única correspondência pode envolver vários grupos de captura, Match tem uma Groups propriedade que retorna o GroupCollection. A Match instância em si é equivalente ao primeiro objeto da coleção, em Match.Groups[0] (Match.Groups(0) em Visual Basic), que representa toda a correspondência. Você pode acessar os grupos capturados em uma correspondência das seguintes maneiras:

Você pode iterar os membros do GroupCollection objeto usando um foreach constructo (C#) ou For Each (Visual Basic).
Você pode usar a GroupCollection.Item[Int32] propriedade para recuperar grupos pelo número do grupo de captura. Observe que você pode determinar quais grupos numerados estão presentes em uma expressão regular chamando o método de instância Regex.GetGroupNumbers .
Você pode usar a GroupCollection.Item[String] propriedade para recuperar grupos pelo nome do grupo de captura. Observe que você pode determinar quais grupos nomeados estão presentes em uma expressão regular chamando o método de instância Regex.GetGroupNames() .

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). A coleção pode ter zero ou mais itens. (Herdado de Group)
Empty	Obtém o grupo vazio. Todas as correspondências com falha retornam essa correspondência vazia.
Groups	Obtém uma coleção de grupos correspondentes à expressão regular.
Index	A posição na cadeia de caracteres original em que foi encontrado o primeiro caractere da subcadeia capturada. (Herdado de Capture)
Length	Obtém o comprimento da subcadeia de caracteres capturada. (Herdado de Capture)
Name	Retorna o nome do grupo de captura representado pela instância atual. (Herdado de Group)
Success	Obtém um valor que indica se a correspondência foi bem-sucedida. (Herdado de Group)
Value	Obtém a subcadeia de caracteres capturada da cadeia de caracteres de entrada. (Herdado de Capture)
ValueSpan	Obtém o intervalo capturado da cadeia de caracteres de entrada. (Herdado de Capture)

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (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).
Result(String)	Retorna a expansão do padrão de substituição especificado.
Synchronized(Match)	Retorna um instância Match equivalente a uma fornecida que é adequada para compartilhar entre vários threads.
ToString()	Recupera a subcadeia de caracteres capturada da cadeia de entrada chamando a propriedade Value. (Herdado de Capture)

Aplica-se a