Regex.Match Método

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input);

public System.Text.RegularExpressions.Match Match (string input);

member this.Match : string -> System.Text.RegularExpressions.Match

Public Function Match (input As String) As Match

Parámetros

Devoluciones

Objeto que contiene información sobre la coincidencia.

Excepciones

Ejemplos

En el ejemplo siguiente se buscan coincidencias de patrón de expresión regular en una cadena y, a continuación, se enumeran los grupos coincidentes, las capturas y las posiciones de captura.

#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;
void main()
{
   
   String^ text = "One car red car blue car";
   String^ pat = "(\\w+)\\s+(car)";
   
   // Compile the regular expression.
   Regex^ r = gcnew Regex( pat,RegexOptions::IgnoreCase );
   
   // Match the regular expression pattern against a text string.
   Match^ m = r->Match(text);
   int matchCount = 0;
   while ( m->Success )
   {
      Console::WriteLine( "Match{0}", ++matchCount );
      for ( int i = 1; i <= 2; i++ )
      {
         Group^ g = m->Groups[ i ];
         Console::WriteLine( "Group{0}='{1}'", i, g );
         CaptureCollection^ cc = g->Captures;
         for ( int j = 0; j < cc->Count; j++ )
         {
            Capture^ c = cc[ j ];
            System::Console::WriteLine( "Capture{0}='{1}', Position={2}", j, c, c->Index );
         }
      }
      m = m->NextMatch();
   }
}  
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

using System;
using System.Text.RegularExpressions;

class Example
{
   static void Main()
   {
      string text = "One car red car blue car";
      string pat = @"(\w+)\s+(car)";

      // Instantiate the regular expression object.
      Regex r = new Regex(pat, RegexOptions.IgnoreCase);

      // Match the regular expression pattern against a text string.
      Match m = r.Match(text);
      int matchCount = 0;
      while (m.Success)
      {
         Console.WriteLine("Match"+ (++matchCount));
         for (int i = 1; i <= 2; i++)
         {
            Group g = m.Groups[i];
            Console.WriteLine("Group"+i+"='" + g + "'");
            CaptureCollection cc = g.Captures;
            for (int j = 0; j < cc.Count; j++)
            {
               Capture c = cc[j];
               System.Console.WriteLine("Capture"+j+"='" + c + "', Position="+c.Index);
            }
         }
         m = m.NextMatch();
      }
   }
}
// This example displays the following output:
//       Match1
//       Group1='One'
//       Capture0='One', Position=0
//       Group2='car'
//       Capture0='car', Position=4
//       Match2
//       Group1='red'
//       Capture0='red', Position=8
//       Group2='car'
//       Capture0='car', Position=12
//       Match3
//       Group1='blue'
//       Capture0='blue', Position=16
//       Group2='car'
//       Capture0='car', Position=21

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim text As String = "One car red car blue car"
      Dim pattern As String = "(\w+)\s+(car)"

      ' Instantiate the regular expression object.
      Dim r As Regex = new Regex(pattern, RegexOptions.IgnoreCase)

      ' Match the regular expression pattern against a text string.
      Dim m As Match = r.Match(text)
      Dim matchcount as Integer = 0
      Do While m.Success
         matchCount += 1
         Console.WriteLine("Match" & (matchCount))
         Dim i As Integer
         For i = 1 to 2
            Dim g as Group = m.Groups(i)
            Console.WriteLine("Group" & i & "='" & g.ToString() & "'")
            Dim cc As CaptureCollection = g.Captures
            Dim j As Integer 
            For j = 0 to cc.Count - 1
              Dim c As Capture = cc(j)
               Console.WriteLine("Capture" & j & "='" & c.ToString() _
                  & "', Position=" & c.Index)
            Next 
         Next 
         m = m.NextMatch()
      Loop
   End Sub
End Module
' This example displays the following output:
'       Match1
'       Group1='One'
'       Capture0='One', Position=0
'       Group2='car'
'       Capture0='car', Position=4
'       Match2
'       Group1='red'
'       Capture0='red', Position=8
'       Group2='car'
'       Capture0='car', Position=12
'       Match3
'       Group1='blue'
'       Capture0='blue', Position=16
'       Group2='car'
'       Capture0='car', Position=21

El patrón de expresión regular (\w+)\s+(car) coincide con las apariciones de la palabra "car" junto con la palabra que lo precede. Se interpreta como se muestra en la tabla siguiente.

Comentarios

El método Match(String) devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos de lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta contiene la subcadena de input que coincide con el patrón de expresión regular. Si no se encuentra ninguna coincidencia, su valor es String.Empty.

Este método devuelve la primera subcadena de input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método Match.NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String).

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un intervalo de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int startat);

public System.Text.RegularExpressions.Match Match (string input, int startat);

member this.Match : string * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, startat As Integer) As Match

Parámetros

Devoluciones

Objeto que contiene información sobre la coincidencia.

Excepciones

Comentarios

Para obtener más información sobre esta API, consulte comentarios de API complementarias para Regex.Match.

Consulte también

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern);

public static System.Text.RegularExpressions.Match Match (string input, string pattern);

static member Match : string * string -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String) As Match

Parámetros

Devoluciones

Objeto que contiene información sobre la coincidencia.

Excepciones

Ejemplos

En el ejemplo siguiente se llama al método Match(String, String) para buscar la primera palabra que contiene al menos un carácter z y, a continuación, llama al método Match.NextMatch para buscar coincidencias adicionales.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example
    {
        public static void Main()
        {
            string input = "ablaze beagle choral dozen elementary fanatic " +
                           "glaze hunger inept jazz kitchen lemon minus " +
                           "night optical pizza quiz restoration stamina " +
                           "train unrest vertical whiz xray yellow zealous";
            string pattern = @"\b\w*z+\w*\b";
            Match m = Regex.Match(input, pattern);
            while (m.Success)
            {
                Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index);
                m = m.NextMatch();
            }
        }
    }
}

// The example displays the following output:
//    'ablaze' found at position 0
//    'dozen' found at position 21
//    'glaze' found at position 46
//    'jazz' found at position 65
//    'pizza' found at position 104
//    'quiz' found at position 110
//    'whiz' found at position 157
//    'zealous' found at position 174

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "ablaze beagle choral dozen elementary fanatic " +
                            "glaze hunger inept jazz kitchen lemon minus " +
                            "night optical pizza quiz restoration stamina " +
                            "train unrest vertical whiz xray yellow zealous"
      Dim pattern As String = "\b\w*z+\w*\b"
      Dim m As Match = Regex.Match(input, pattern)
      Do While m.Success 
         Console.WriteLine("'{0}' found at position {1}", m.Value, m.Index)
         m = m.NextMatch()
      Loop                      
   End Sub
End Module
' The example displays the following output:
    'ablaze' found at position 0
    'dozen' found at position 21
    'glaze' found at position 46
    'jazz' found at position 65
    'pizza' found at position 104
    'quiz' found at position 110
    'whiz' found at position 157
    'zealous' found at position 174

El patrón de expresión regular \b\w*z+\w*\b se interpreta como se muestra en la tabla siguiente.

Comentarios

El método Match(String, String) devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos de lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

El método Match(String, String) estático es equivalente a construir un objeto Regex con el patrón de expresión regular especificado y llamar al método Match(String) de instancia. En este caso, el motor de expresiones regulares almacena en caché el patrón de expresión regular.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta contiene la subcadena de input que coincide con el patrón de expresión regular. Si no se encuentra ninguna coincidencia, su valor es String.Empty.

Este método devuelve la primera subcadena de input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método Match.NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String, String).

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para recuperar una coincidencia de patrón es Match(String, String), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 System::Text::RegularExpressions::Match ^ Match(System::String ^ input, int beginning, int length);

public System.Text.RegularExpressions.Match Match (string input, int beginning, int length);

member this.Match : string * int * int -> System.Text.RegularExpressions.Match

Public Function Match (input As String, beginning As Integer, length As Integer) As Match

Parámetros

Devoluciones

Objeto que contiene información sobre la coincidencia.

Excepciones

Comentarios

El método Match(String, Int32, Int32) devuelve la primera subcadena que coincide con un patrón de expresión regular en una parte de una cadena de entrada. Para obtener información sobre los elementos de lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

El patrón de expresión regular para el que busca el método Match(String, Int32, Int32) se define mediante la llamada a uno de los constructores de clase Regex. Para obtener más información sobre los elementos que pueden formar un patrón de expresión regular, vea lenguaje de expresiones regulares: referencia rápida.

El método Match(String, Int32, Int32) busca en la parte de input definida por los parámetros beginning y length para el patrón de expresión regular. beginning define siempre el índice del carácter más a la izquierda que se va a incluir en la búsqueda y length define el número máximo de caracteres que se van a buscar. Juntos definen el intervalo de la búsqueda. El comportamiento es exactamente igual que si el input se input.Substring(beginning, length)de forma eficaz, excepto que el índice de cualquier coincidencia se cuenta con respecto al inicio de input. Esto significa que los delimitadores o aserciones de ancho cero al principio o al final del patrón se comportan como si no hubiera ningún input fuera de este intervalo. Por ejemplo, los delimitadores ^, \Gy \A se cumplirán en beginning y $ y \z se cumplirán en beginning + length - 1.

Si la búsqueda continúa de izquierda a derecha (valor predeterminado), el motor de expresiones regulares busca desde el carácter en el índice beginning al carácter en el índice beginning + length - 1. Si se creó una instancia del motor de expresiones regulares mediante la opción RegexOptions.RightToLeft para que la búsqueda continúe de derecha a izquierda, el motor de expresiones regulares busca desde el carácter en el índice beginning + length - 1 al carácter en el índice beginning.

Este método devuelve la primera coincidencia que encuentra dentro de este intervalo. Puede recuperar coincidencias posteriores llamando repetidamente al método Match.NextMatch del objeto devuelto Match.

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta contiene la subcadena de input que coincide con el patrón de expresión regular. Si no se encuentra ninguna coincidencia, su valor es String.Empty.

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el constructor Regex.Regex(String, RegexOptions, TimeSpan). Si no establece un valor de tiempo de espera al llamar al constructor, se produce la excepción si la operación supera cualquier valor de tiempo de espera establecido para el dominio de aplicación en el que se crea el objeto Regex. Si no se define ningún tiempo de espera en la llamada del constructor de Regex o en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Consulte también

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions) As Match

Parámetros

Devoluciones

Objeto que contiene información sobre la coincidencia.

Excepciones

Ejemplos

En el ejemplo siguiente se define una expresión regular que coincide con las palabras que comienzan con la letra "a". Usa la opción RegexOptions.IgnoreCase para asegurarse de que la expresión regular busca palabras que comienzan con una "a" mayúscula y una "a" minúscula.

using System;
using System.Text.RegularExpressions;

namespace Examples
{
    public class Example2
    {
        public static void Main()
        {
            string pattern = @"\ba\w*\b";
            string input = "An extraordinary day dawns with each new day.";
            Match m = Regex.Match(input, pattern, RegexOptions.IgnoreCase);
            if (m.Success)
                Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index);
        }
    }
}

// The example displays the following output:
//        Found 'An' at position 0.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\ba\w*\b"
      Dim input As String = "An extraordinary day dawns with each new day."
      Dim m As Match = Regex.Match(input, pattern, RegexOptions.IgnoreCase)
      If m.Success Then
         Console.WriteLine("Found '{0}' at position {1}.", m.Value, m.Index)
      End If
   End Sub
End Module
' The example displays the following output:
'       Found 'An' at position 0.

El patrón de expresión regular \ba\w*\b se interpreta como se muestra en la tabla siguiente.

Comentarios

El método Match(String, String, RegexOptions) devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos de lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

El método Match(String, String, RegexOptions) estático equivale a construir un objeto Regex con el constructor Regex(String, RegexOptions) y llamar al método Match(String) de instancia.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta contiene la subcadena de input que coincide con el patrón de expresión regular. Si no se encuentra ninguna coincidencia, su valor es String.Empty.

Este método devuelve la primera subcadena que se encuentra en input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String, String, RegexOptions).

La excepción RegexMatchTimeoutException se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado para el dominio de aplicación en el que se llama al método . Si no se define ningún tiempo de espera en las propiedades del dominio de aplicación, o si el valor de tiempo de espera es Regex.InfiniteMatchTimeout, no se produce ninguna excepción.

Notas a los autores de las llamadas

Este método agota el tiempo de espera después de un intervalo que es igual al valor de tiempo de espera predeterminado del dominio de aplicación en el que se llama. Si no se ha definido un valor de tiempo de espera para el dominio de aplicación, se usa el valor InfiniteMatchTimeout, que impide que se agote el tiempo de espera del método. El método estático recomendado para recuperar una coincidencia de patrón es Match(String, String), lo que le permite establecer el intervalo de tiempo de espera.

Consulte también

• NextMatch()
• lenguaje de expresiones regulares: de referencia rápida

Source:

Regex.Match.cs

Source:

Regex.Match.cs

Source:

Regex.Match.cs

public:
 static System::Text::RegularExpressions::Match ^ Match(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static System.Text.RegularExpressions.Match Match (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Match : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Match

Public Shared Function Match (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Match

Parámetros

Devoluciones

Objeto que contiene información sobre la coincidencia.

Excepciones

Comentarios

El método Match(String, String, RegexOptions, TimeSpan) devuelve la primera subcadena que coincide con un patrón de expresión regular en una cadena de entrada. Para obtener información sobre los elementos de lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: referencia rápida.

El método Match(String, String, RegexOptions, TimeSpan) estático equivale a construir un objeto Regex con el constructor Regex(String, RegexOptions, TimeSpan) y llamar al método Match(String) de instancia.

El parámetro pattern consta de elementos del lenguaje de expresiones regulares que describen simbólicamente la cadena que debe coincidir. Para obtener más información sobre las expresiones regulares, vea expresiones regulares de .NET y lenguaje de expresiones regulares: referencia rápida.

Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad Success del objeto Match devuelto. Si se encuentra una coincidencia, la propiedad Value del objeto Match devuelta contiene la subcadena de input que coincide con el patrón de expresión regular. Si no se encuentra ninguna coincidencia, su valor es String.Empty.

Este método devuelve la primera subcadena que se encuentra en input que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método NextMatch del objeto devuelto Match. También puede recuperar todas las coincidencias en una sola llamada al método Regex.Matches(String, String, RegexOptions).

El parámetro matchTimeout especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que se agote el tiempo de espera. Si se establece un intervalo de tiempo de espera, se impide que las expresiones regulares que se basan en un retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea procedimientos recomendados de para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una excepción RegexMatchTimeoutException. matchTimeout invalida cualquier valor de tiempo de espera predeterminado definido para el dominio de aplicación en el que se ejecuta el método.

Notas a los autores de las llamadas

Se recomienda establecer el parámetro matchTimeout en un valor adecuado, como dos segundos. Si deshabilita los tiempos de espera especificando InfiniteMatchTimeout, el motor de expresiones regulares ofrece un rendimiento ligeramente mejor. Sin embargo, debe deshabilitar los tiempos de espera solo en las condiciones siguientes:

• Cuando la entrada procesada por una expresión regular se deriva de un origen conocido y de confianza o consta de texto estático. Esto excluye el texto que los usuarios han introducido dinámicamente.

• Cuando el patrón de expresión regular se ha probado exhaustivamente para asegurarse de que controla eficazmente las coincidencias, las no coincide y las coincidencias cercanas.

• Cuando el patrón de expresión regular no contiene elementos de lenguaje que se sabe que provocan un retroceso excesivo al procesar una coincidencia cercana.

Consulte también

• lenguaje de expresiones regulares: de referencia rápida