Match Clase

Definición

Representa los resultados de una única coincidencia de expresiones regulares.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
Herencia
Atributos

Ejemplos

En los ejemplos siguientes se usa la expresión regular Console\.Write(Line)?.The following examples use the regular expression Console\.Write(Line)?. La expresión regular se interpreta como sigue:The regular expression is interpreted as follows:

\de consola. EscribiConsole\.Write Coincide con la cadena "Console.Write".Match the string "Console.Write". Tenga en cuenta que el carácter "." se convierte en caracteres de escape para que se interprete como un punto literal, en lugar de como un carácter comodín que coincide con cualquier carácter.Note that the "." character is escaped so that it is interpreted as a literal period rather than as a wildcard that matches any character.
(Línea)?(Line)? Coincide con cero o una repetición de la cadena "Line".Match zero or one occurrence of the string "Line".

Ejemplo 1Example 1

En el ejemplo siguiente se llama al método Regex.Matches(String, String) para recuperar todas las coincidencias de patrón en una cadena de entrada.The following example calls the Regex.Matches(String, String) method to retrieve all pattern matches in an input string. A continuación, recorre en iteración los objetos Match del objeto MatchCollection devuelto para mostrar información sobre cada coincidencia.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.

Ejemplo 2Example 2

En el ejemplo siguiente se llama a los métodos Match(String, String) y NextMatch para recuperar una coincidencia 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.

Comentarios

El objeto Match es inmutable y no tiene ningún constructor público.The Match object is immutable and has no public constructor. El método Regex.Match devuelve una instancia de la clase Match y representa la primera coincidencia de patrones de una cadena.An instance of the Match class is returned by the Regex.Match method and represents the first pattern match in a string. Las coincidencias subsiguientes se representan mediante Match objetos devueltos por el método Match.NextMatch.Subsequent matches are represented by Match objects returned by the Match.NextMatch method. Además, el método Regex.Matches devuelve un objeto MatchCollection que consta de cero, uno o más objetos Match.In addition, a MatchCollection object that consists of zero, one, or more Match objects is returned by the Regex.Matches method.

Si el método Regex.Matches no coincide con un patrón de expresión regular en una cadena de entrada, devuelve un objeto MatchCollection vacío.If the Regex.Matches method fails to match a regular expression pattern in an input string, it returns an empty MatchCollection object. Después, puede usar una construcción foreach en C# o una construcción For Each de Visual Basic para recorrer en iteración la colección.You can then use a foreach construct in C# or a For Each construct in Visual Basic to iterate the collection.

Si el método Regex.Match no coincide con el patrón de expresión regular, devuelve un objeto Match que es 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. Puede usar la propiedad Success para determinar si la coincidencia se realizó correctamente.You can use the Success property to determine whether the match was successful. En el ejemplo siguiente se propociona una ilustración.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 una coincidencia de patrón se realiza correctamente, la propiedad Value contiene la subcadena coincidente, la propiedad Index indica la posición inicial de base cero de la subcadena coincidente en la cadena de entrada y la propiedad Length indica la longitud de la subcadena coincidente en la cadena 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.

Dado que una única coincidencia puede implicar varios grupos de captura, Match tiene una propiedad Groups que devuelve el GroupCollection.Because a single match can involve multiple capturing groups, Match has a Groups property that returns the GroupCollection. La propia instancia de Match es equivalente al primer objeto de la colección, en Match.Groups[0] (Match.Groups(0) en Visual Basic), que representa la coincidencia completa.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. Puede tener acceso a los grupos capturados en una coincidencia de las siguientes maneras:You can access the captured groups in a match in the following ways:

  • Puede iterar los miembros del objeto GroupCollection mediante una construcción foreach (C#) o For Each (Visual Basic).You can iterate the members of the GroupCollection object by using a foreach (C#) or For Each (Visual Basic) construct.

  • Puede usar la propiedad GroupCollection.Item[Int32] para recuperar grupos por el número del grupo de captura.You can use the GroupCollection.Item[Int32] property to retrieve groups by the number of the capturing group. Tenga en cuenta que puede determinar qué grupos numerados están presentes en una expresión regular llamando al método de la instancia Regex.GetGroupNumbers.Note that you can determine which numbered groups are present in a regular expression by calling the instance Regex.GetGroupNumbers method.

  • Puede usar la propiedad GroupCollection.Item[String] para recuperar grupos por el nombre del grupo de captura.You can use the GroupCollection.Item[String] property to retrieve groups by the name of the capturing group. Tenga en cuenta que puede determinar qué grupos con nombre están presentes en una expresión regular llamando al método de la instancia Regex.GetGroupNames().Note that you can determine which named groups are present in a regular expression by calling the instance Regex.GetGroupNames() method.

Propiedades

Captures

Obtiene una colección de todas las capturas que coinciden con el grupo de captura, en orden empezando por el más interno de la izquierda (o por el más interno de la derecha si se modifica con la opción 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 colección puede tener cero o más elementos.The collection may have zero or more items.

(Heredado de Group)
Empty

Obtiene el grupo vacío.Gets the empty group. Todas las coincidencias erróneas devuelven esta coincidencia vacía.All failed matches return this empty match.

Groups

Obtiene una colección de grupos que coinciden con la expresión regular.Gets a collection of groups matched by the regular expression.

Index

Posición en la cadena original donde se encuentra el primer carácter de la subcadena capturada.The position in the original string where the first character of the captured substring is found.

(Heredado de Capture)
Length

Obtiene la longitud de la subcadena capturada.Gets the length of the captured substring.

(Heredado de Capture)
Name

Devuelve el nombre del grupo de captura que la instancia actual representa.Returns the name of the capturing group represented by the current instance.

(Heredado de Group)
Success

Obtiene un valor que indica si la coincidencia ha tenido éxito.Gets a value indicating whether the match is successful.

(Heredado de Group)
Value

Obtiene la subcadena capturada desde la cadena de entrada.Gets the captured substring from the input string.

(Heredado de Capture)

Métodos

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
NextMatch()

Devuelve un nuevo objeto Match con los resultados de la siguiente coincidencia, empezando en la posición donde finalizó la última (en el carácter siguiente al último que coincidía).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)

Devuelve la expansión del patrón de reemplazo especificado.Returns the expansion of the specified replacement pattern.

Synchronized(Match)

Devuelve una instancia de Match equivalente al suministrado que es adecuado para compartirse entre varios subprocesos.Returns a Match instance equivalent to the one supplied that is suitable to share between multiple threads.

ToString()

Recupera la subcadena capturada de la cadena de entrada llamando a la propiedad Value.Retrieves the captured substring from the input string by calling the Value property.

(Heredado de Capture)

Se aplica a

Consulte también: