Match Classe

Definição

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:

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

Métodos

Aplica-se a

Confira também

• MatchCollection
• Regex