Regex.Match Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Busca en una cadena de entrada una subcadena que coincida con un modelo de expresión regular y devuelve la primera aparición como un único objeto Match.
Sobrecargas
Match(String, String, RegexOptions) |
Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia indicadas. |
Match(String) |
Busca en la cadena de entrada especificada la primera aparición de la expresión regular especificada en el constructor Regex. |
Match(String, Int32) |
Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada de la cadena. |
Match(String, String) |
Busca en la cadena de entrada especificada la primera aparición de la expresión regular indicada. |
Match(String, Int32, Int32) |
Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada y buscando solo en el número de caracteres indicado. |
Match(String, String, RegexOptions, TimeSpan) |
Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se indiquen. |
Match(String, String, RegexOptions)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia indicadas.
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
- input
- String
Cadena en la que se va a buscar una coincidencia.
- pattern
- String
Patrón de expresión regular del que van a buscarse coincidencias.
- options
- RegexOptions
Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.
Devoluciones
Objeto que contiene información sobre la coincidencia.
Excepciones
Se produjo un error de análisis de expresión regular.
input
o pattern
es null
.
options
no es una combinación bit a bit válida de valores RegexOptions.
Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.
Ejemplos
En el ejemplo siguiente se define una expresión regular que coincide con las palabras que comienzan por la letra "a". Usa la RegexOptions.IgnoreCase opción 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 la expresión regular \ba\w*\b
se interpreta como se muestra en la tabla siguiente.
Modelo | Descripción |
---|---|
\b |
Iniciar la búsqueda de coincidencias en un límite de palabras. |
a |
Coincide con el carácter "a". |
\w* |
Coincide con cero, uno o más caracteres de palabra. |
\b |
Finalizar la búsqueda de coincidencias en un límite de palabras. |
Comentarios
El Match(String, String, RegexOptions) método 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 usados para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.
El método estático Match(String, String, RegexOptions) es equivalente a construir un Regex objeto con el Regex(String, RegexOptions) constructor y llamar al método de instancia Match(String) .
El pattern
parámetro 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 del Success objeto devueltoMatch. Si se encuentra una coincidencia, la propiedad del Value objeto devuelto Match 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 encontrada en input
que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método del NextMatch objeto devueltoMatch. También puede recuperar todas las coincidencias en una sola llamada de método llamando al Regex.Matches(String, String, RegexOptions) método .
La RegexMatchTimeoutException excepción 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
Se aplica a
Match(String)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Busca en la cadena de entrada especificada la primera aparición de la expresión regular especificada en el constructor Regex.
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
- input
- String
Cadena en la que se va a buscar una coincidencia.
Devoluciones
Objeto que contiene información sobre la coincidencia.
Excepciones
input
es null
.
Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.
Ejemplos
En el ejemplo siguiente se buscan coincidencias de patrones 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 (\w+)\s+(car)
de expresión regular coincide con las apariciones de la palabra "car" junto con la palabra que lo precede. Se interpreta como se muestra en la tabla siguiente.
Patrón | Descripción |
---|---|
(\w+) |
Buscar coincidencias con uno o más caracteres alfabéticos. Este es el primer grupo de captura. |
\s+ |
Coincide con uno o varios caracteres de espacio en blanco. |
(coche) | Coincide con la cadena literal "car". Este es el segundo grupo de captura. |
Comentarios
El Match(String) método 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 usados 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 del Success objeto devueltoMatch. Si se encuentra una coincidencia, la propiedad del Value objeto devuelto Match 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 del Match.NextMatch objeto devueltoMatch. También puede recuperar todas las coincidencias en una sola llamada de método llamando al Regex.Matches(String) método .
La RegexMatchTimeoutException excepción se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 Regex objeto. Si no se define ningún tiempo de espera en la llamada del Regex constructor 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
Se aplica a
Match(String, Int32)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada de la cadena.
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
- input
- String
Cadena en la que se va a buscar una coincidencia.
- startat
- Int32
Posición de carácter basada en cero en la que se va a iniciar la búsqueda.
Devoluciones
Objeto que contiene información sobre la coincidencia.
Excepciones
input
es null
.
startat
es menor que cero o mayor que la longitud de input
.
Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.
Comentarios
Para obtener más información sobre esta API, consulte Comentarios complementarios de la API para Regex.Match.
Consulte también
Se aplica a
Match(String, String)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Busca en la cadena de entrada especificada la primera aparición de la expresión regular indicada.
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
- input
- String
Cadena en la que se va a buscar una coincidencia.
- pattern
- String
Patrón de expresión regular del que van a buscarse coincidencias.
Devoluciones
Objeto que contiene información sobre la coincidencia.
Excepciones
Se produjo un error de análisis de expresión regular.
input
o pattern
es null
.
Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.
Ejemplos
En el ejemplo siguiente se llama al Match(String, String) método para buscar la primera palabra que contiene al menos un z
carácter y, a continuación, llama al Match.NextMatch método 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 la expresión regular \b\w*z+\w*\b
se interpreta como se muestra en la tabla siguiente.
Modelo | Descripción |
---|---|
\b |
Iniciar la búsqueda de coincidencias en un límite de palabras. |
\w* |
Coincide con cero, uno o más caracteres de palabra. |
z+ |
Coincide con una o varias apariciones del z carácter. |
\w* |
Coincide con cero, uno o más caracteres de palabra. |
\b |
Finalizar la búsqueda de coincidencias en un límite de palabras. |
Comentarios
El Match(String, String) método 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 del lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.
El método estático Match(String, String) es equivalente a construir un Regex objeto con el patrón de expresión regular especificado y llamar al método de instancia Match(String) . En este caso, el motor de expresiones regulares almacena en caché el patrón de expresión regular.
El pattern
parámetro 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 del Success objeto devueltoMatch. Si se encuentra una coincidencia, la propiedad del Value objeto devuelto Match 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 del Match.NextMatch objeto devueltoMatch. También puede recuperar todas las coincidencias en una sola llamada de método llamando al Regex.Matches(String, String) método .
La RegexMatchTimeoutException excepción 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
Se aplica a
Match(String, Int32, Int32)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Busca en la cadena de entrada la primera aparición de una expresión regular, empezando en la posición inicial especificada y buscando solo en el número de caracteres indicado.
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
- input
- String
Cadena en la que se va a buscar una coincidencia.
- beginning
- Int32
Posición de caracteres de base cero en la cadena de entrada que define la posición más a la izquierda en la que se buscará.
- length
- Int32
Número de caracteres de la subcadena que se van a incluir en la búsqueda.
Devoluciones
Objeto que contiene información sobre la coincidencia.
Excepciones
input
es null
.
beginning
es menor que cero o mayor que la longitud de input
.
O bien
length
es menor que cero o mayor que la longitud de input
.
O bien
beginning
+
length
-1
identifica una posición que está fuera del intervalo de input
.
Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.
Comentarios
El Match(String, Int32, Int32) método 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 del 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 Match(String, Int32, Int32) método se define mediante la llamada a uno de los Regex constructores de clase. 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 Match(String, Int32, Int32) método busca en la parte de input
definida por los beginning
parámetros y length
para el patrón de expresión regular. beginning
define siempre el índice del carácter situado 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 input
era eficaz input.Substring(beginning, length)
, excepto que el índice de cualquier coincidencia se cuenta con respecto al inicio de input
. Esto significa que cualquier delimitador o aserciones de ancho cero al principio o al final del patrón se comporta como si no hubiera ninguna input
fuera de este intervalo. Por ejemplo, los delimitadores , y se cumplirán en beginning
y $
\z
y se cumplirán en beginning + length - 1
.\A
\G
^
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
hasta el carácter en el índice beginning + length - 1
. Si se creó una instancia del motor de expresiones regulares mediante la RegexOptions.RightToLeft opción 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
hasta el carácter del índice beginning
.
Este método devuelve la primera coincidencia que encuentra dentro de este intervalo. Puede recuperar coincidencias posteriores llamando repetidamente al método del Match.NextMatch objeto devueltoMatch.
Puede determinar si el patrón de expresión regular se ha encontrado en la cadena de entrada comprobando el valor de la propiedad del Success objeto devueltoMatch. Si se encuentra una coincidencia, la propiedad del Value objeto devuelto Match 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 RegexMatchTimeoutException excepción se produce si el tiempo de ejecución de la operación coincidente supera el intervalo de tiempo de espera especificado por el Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 Regex objeto. Si no se define ningún tiempo de espera en la Regex llamada del constructor 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
Se aplica a
Match(String, String, RegexOptions, TimeSpan)
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
- Source:
- Regex.Match.cs
Busca en la cadena de entrada la primera aparición de la expresión regular especificada, utilizando para ello las opciones de coincidencia y el intervalo de tiempo de espera que se indiquen.
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
- input
- String
Cadena en la que se va a buscar una coincidencia.
- pattern
- String
Patrón de expresión regular del que van a buscarse coincidencias.
- options
- RegexOptions
Combinación bit a bit de los valores de enumeración que proporcionan opciones de coincidencia.
- matchTimeout
- TimeSpan
Un intervalo de tiempo de espera, o InfiniteMatchTimeout para indicar que el método no debe agotar el tiempo de espera.
Devoluciones
Objeto que contiene información sobre la coincidencia.
Excepciones
Se produjo un error de análisis de expresión regular.
input
o pattern
es null
.
options
no es una combinación bit a bit válida de valores RegexOptions.
O bien
matchTimeout
es negativo, cero o mayor que 24 días aproximadamente.
Se agotó el tiempo de espera. Para más información sobre los tiempos de espera, vea la sección Comentarios.
Comentarios
El Match(String, String, RegexOptions, TimeSpan) método 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 del lenguaje que se usan para crear un patrón de expresión regular, vea Lenguaje de expresiones regulares: Referencia rápida.
El método estático Match(String, String, RegexOptions, TimeSpan) es equivalente a construir un Regex objeto con el Regex(String, RegexOptions, TimeSpan) constructor y llamar al método de instancia Match(String) .
El pattern
parámetro 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 del Success objeto devueltoMatch. Si se encuentra una coincidencia, la propiedad del Value objeto devuelto Match 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 encontrada en input
que coincide con el patrón de expresión regular. Puede recuperar coincidencias posteriores llamando repetidamente al método del NextMatch objeto devueltoMatch. También puede recuperar todas las coincidencias en una sola llamada de método llamando al Regex.Matches(String, String, RegexOptions) método .
El matchTimeout
parámetro especifica cuánto tiempo un método de coincidencia de patrones debe intentar encontrar una coincidencia antes de que agote el tiempo de espera. Establecer un intervalo de tiempo de espera impide que las expresiones regulares que dependen del retroceso excesivo aparezcan para dejar de responder cuando procesan la entrada que contiene coincidencias cercanas. Para obtener más información, vea Procedimientos recomendados para expresiones regulares y retroceso. Si no se encuentra ninguna coincidencia en ese intervalo de tiempo, el método produce una RegexMatchTimeoutException excepción. 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 matchTimeout
parámetro 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 de forma eficaz 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
Se aplica a
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta:Enviar y ver comentarios de