Match Clase

Definición

Espacio de nombres:

System.Text.RegularExpressions

Ensamblado:

System.Text.RegularExpressions.dll

Ensamblado:

System.dll

Ensamblado:

netstandard.dll

Representa los resultados de una sola coincidencia de expresión 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

Herencia

Object

Capture

Group

Match

Atributos

SerializableAttribute

Ejemplos

En los ejemplos siguientes se usa la expresión Console\.Write(Line)?regular . La expresión regular se interpreta como sigue:

Consola\. Escribir	Coincide con la cadena "Console.Write". Tenga en cuenta que el carácter "." se escapa para que se interprete como un punto literal en lugar de comodín que coincida con cualquier carácter.
(Línea)?	Coincide con cero o una repetición de la cadena "Line".

Ejemplo 1

En el ejemplo siguiente se llama al Regex.Matches(String, String) método para recuperar todas las coincidencias de patrones en una cadena de entrada. A continuación, recorre en iteración los Match objetos del objeto devuelto MatchCollection para mostrar información sobre cada coincidencia.

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.

Ejemplo 2

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

Comentarios

El Match objeto es inmutable y no tiene ningún constructor público. El método devuelve Regex.Match una instancia de la Match clase y representa la primera coincidencia de patrón en una cadena. Las coincidencias posteriores se representan mediante Match objetos devueltos por el Match.NextMatch método . Además, el Regex.Matches método devuelve un MatchCollection objeto que consta de cero, uno o más Match objetos.

Si el Regex.Matches método no coincide con un patrón de expresión regular en una cadena de entrada, devuelve un objeto vacío MatchCollection . A continuación, puede usar una foreach construcción en C# o una For Each construcción en Visual Basic para iterar la colección.

Si el Regex.Match método no coincide con el patrón de expresión regular, devuelve un Match objeto que es igual a Match.Empty. Puede usar la Success propiedad para determinar si la coincidencia se realizó correctamente. Esto se muestra en el ejemplo siguiente.

// 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 es correcta, la Value propiedad contiene la subcadena coincidente, la Index propiedad indica la posición inicial de base cero de la subcadena coincidente en la cadena de entrada y la Length propiedad indica la longitud de la subcadena coincidente en la cadena de entrada.

Dado que una sola coincidencia puede implicar varios grupos de captura, Match tiene una Groups propiedad que devuelve .GroupCollection La Match propia instancia es equivalente al primer objeto de la colección, en Match.Groups[0] (Match.Groups(0) en Visual Basic), que representa toda la coincidencia. Puede acceder a los grupos capturados de una coincidencia de las siguientes maneras:

• Puede iterar los miembros del GroupCollection objeto mediante una foreach construcción (C#) o For Each (Visual Basic).

• Puede usar la GroupCollection.Item[Int32] propiedad para recuperar grupos por el número del grupo de captura. Tenga en cuenta que puede determinar qué grupos numerados están presentes en una expresión regular llamando al método de instancia Regex.GetGroupNumbers .

• Puede usar la GroupCollection.Item[String] propiedad para recuperar grupos por el nombre del grupo de captura. Tenga en cuenta que puede determinar qué grupos con nombre están presentes en una expresión regular llamando al método de instancia Regex.GetGroupNames() .

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). La colección puede tener cero o más elementos. (Heredado de Group)
Empty	Obtiene el grupo vacío. Todas las coincidencias erróneas devuelven esta coincidencia vacía.
Groups	Obtiene una colección de grupos que coinciden con la expresión regular.
Index	Posición en la cadena original donde se encuentra el primer carácter de la subcadena capturada. (Heredado de Capture)
Length	Obtiene la longitud de la subcadena capturada. (Heredado de Capture)
Name	Devuelve el nombre del grupo de captura que la instancia actual representa. (Heredado de Group)
Success	Obtiene un valor que indica si la coincidencia ha tenido éxito. (Heredado de Group)
Value	Obtiene la subcadena capturada desde la cadena de entrada. (Heredado de Capture)
ValueSpan	Obtiene el intervalo capturado de la cadena de entrada. (Heredado de Capture)

Métodos

Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (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).
Result(String)	Devuelve la expansión del patrón de reemplazo especificado.
Synchronized(Match)	Devuelve una instancia de Match equivalente a la suministrada que es adecuada para compartirse entre varios subprocesos.
ToString()	Recupera la subcadena capturada de la cadena de entrada llamando a la propiedad Value. (Heredado de Capture)

Consulte también

• MatchCollection
• Regex