Regex.Match Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Pesquisa uma cadeia de caracteres de entrada para uma subcadeia de caracteres que corresponde a um padrão de expressão regular e retorna a primeira ocorrência como um único objeto Match.
Sobrecargas
Match(String) |
Pesquisa a cadeia de caracteres de entrada especificada para a primeira ocorrência da expressão regular especificada no construtor Regex. |
Match(String, Int32) |
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres. |
Match(String, String) |
Pesquisa a cadeia de caracteres de entrada especificada para a primeira ocorrência da expressão regular especificada. |
Match(String, Int32, Int32) |
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres. |
Match(String, String, RegexOptions) |
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções de correspondência especificadas. |
Match(String, String, RegexOptions, TimeSpan) |
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções de correspondência especificadas e o intervalo de tempo limite. |
Match(String)
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
Pesquisa a cadeia de caracteres de entrada especificada para a primeira ocorrência da expressão regular especificada no construtor 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
A cadeia de caracteres a ser pesquisada por uma correspondência.
Retornos
Um objeto que contém informações sobre a correspondência.
Exceções
input
é null
.
Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.
Exemplos
O exemplo a seguir localiza correspondências de padrão de expressão regular em uma cadeia de caracteres e, em seguida, lista os grupos, capturas e posições de captura correspondentes.
#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
O padrão de expressão regular (\w+)\s+(car)
corresponde às ocorrências da palavra "carro" junto com a palavra que o precede. Ele é interpretado conforme mostrado na tabela a seguir.
Padrão | Descrição |
---|---|
(\w+) |
Corresponde a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. |
\s+ |
Corresponde a um ou mais caracteres de espaço em branco. |
(carro) | Corresponda à cadeia de caracteres literal "car". Este é o segundo grupo de captura. |
Comentários
O método Match(String) retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular - Referência Rápida.
Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input
que corresponde ao padrão de expressão regular. Se nenhuma correspondência for encontrada, seu valor será String.Empty.
Esse método retorna a primeira subcadeia de caracteres em input
que corresponde ao padrão de expressão regular. Você pode recuperar correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String).
A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). Se você não definir um intervalo de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.
Confira também
- NextMatch()
- linguagem de expressão regular – referência rápida
Aplica-se a
Match(String, Int32)
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada na cadeia de caracteres.
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
A cadeia de caracteres a ser pesquisada por uma correspondência.
- startat
- Int32
A posição do caractere baseado em zero na qual iniciar a pesquisa.
Retornos
Um objeto que contém informações sobre a correspondência.
Exceções
input
é null
.
startat
é menor que zero ou maior que o comprimento de input
.
Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.
Comentários
Para obter mais informações sobre essa API, consulte comentários da API Suplementar para Regex.Match.
Confira também
- NextMatch()
- linguagem de expressão regular – referência rápida
Aplica-se a
Match(String, String)
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
Pesquisa a cadeia de caracteres de entrada especificada para a primeira ocorrência da expressão regular especificada.
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
A cadeia de caracteres a ser pesquisada por uma correspondência.
- pattern
- String
O padrão de expressão regular a ser correspondido.
Retornos
Um objeto que contém informações sobre a correspondência.
Exceções
Ocorreu um erro de análise de expressão regular.
input
ou pattern
é null
.
Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.
Exemplos
O exemplo a seguir chama o método Match(String, String) para localizar a primeira palavra que contém pelo menos um caractere z
e, em seguida, chama o método Match.NextMatch para localizar quaisquer correspondências adicionais.
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
O padrão de expressão regular \b\w*z+\w*\b
é interpretado conforme mostrado na tabela a seguir.
Padrão | Descrição |
---|---|
\b |
Inicie a correspondência em um limite de palavra. |
\w* |
Corresponder a zero, um ou mais caracteres de palavra. |
z+ |
Corresponde a uma ou mais ocorrências do caractere z . |
\w* |
Corresponder a zero, um ou mais caracteres de palavra. |
\b |
Encerre a correspondência em um limite de palavra. |
Comentários
O método Match(String, String) retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular - Referência Rápida.
O método Match(String, String) estático é equivalente à construção de um objeto Regex com o padrão de expressão regular especificado e chamar a instância Match(String) método. Nesse caso, o mecanismo de expressão regular armazena em cache o padrão de expressão regular.
O parâmetro pattern
consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.
Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input
que corresponde ao padrão de expressão regular. Se nenhuma correspondência for encontrada, seu valor será String.Empty.
Esse método retorna a primeira subcadeia de caracteres em input
que corresponde ao padrão de expressão regular. Você pode recuperar correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String).
A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.
Notas aos Chamadores
Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado. O método estático recomendado para recuperar uma correspondência de padrão é Match(String, String), o que permite definir o intervalo de tempo limite.
Confira também
- NextMatch()
- linguagem de expressão regular – referência rápida
Aplica-se a
Match(String, Int32, Int32)
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência de uma expressão regular, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres.
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
A cadeia de caracteres a ser pesquisada por uma correspondência.
- beginning
- Int32
A posição do caractere baseado em zero na cadeia de caracteres de entrada que define a posição mais à esquerda a ser pesquisada.
- length
- Int32
O número de caracteres na subcadeia de caracteres a serem incluídos na pesquisa.
Retornos
Um objeto que contém informações sobre a correspondência.
Exceções
input
é null
.
beginning
é menor que zero ou maior que o comprimento de input
.
-ou-
length
é menor que zero ou maior que o comprimento de input
.
-ou-
beginning
+
length
-1
identifica uma posição fora do intervalo de input
.
Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.
Comentários
O método Match(String, Int32, Int32) retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma parte de uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular - Referência Rápida.
O padrão de expressão regular para o qual o método Match(String, Int32, Int32) pesquisa é definido pela chamada para um dos construtores de classe Regex. Para obter mais informações sobre os elementos que podem formar um padrão de expressão regular, consulte Linguagem de Expressão Regular - Referência Rápida.
O método Match(String, Int32, Int32) pesquisa a parte de input
definida pelos parâmetros beginning
e length
para o padrão de expressão regular.
beginning
sempre define o índice do caractere mais à esquerda a ser incluído na pesquisa e length
define o número máximo de caracteres a serem pesquisados. Juntos, eles definem o intervalo da pesquisa. O comportamento é exatamente como se o input
fosse efetivamente input.Substring(beginning, length)
, exceto que o índice de qualquer correspondência é contado em relação ao início de input
. Isso significa que as âncoras ou asserções de largura zero no início ou no final do padrão se comportam como se não houvesse input
fora desse intervalo. Por exemplo, as âncoras ^
, \G
e \A
serão atendidas em beginning
e $
e \z
serão atendidos em beginning + length - 1
.
Se a pesquisa continuar da esquerda para a direita (o padrão), o mecanismo de expressão regular pesquisa do caractere no índice beginning
para o caractere no índice beginning + length - 1
. Se o mecanismo de expressão regular tiver sido instanciado usando a opção RegexOptions.RightToLeft para que a pesquisa prossiga da direita para a esquerda, o mecanismo de expressão regular pesquisa do caractere no índice beginning + length - 1
para o caractere no índice beginning
.
Esse método retorna a primeira correspondência encontrada dentro desse intervalo. Você pode recuperar correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto Match retornado.
Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input
que corresponde ao padrão de expressão regular. Se nenhuma correspondência for encontrada, seu valor será String.Empty.
A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado pelo construtor Regex.Regex(String, RegexOptions, TimeSpan). Se você não definir um valor de tempo limite ao chamar o construtor, a exceção será gerada se a operação exceder qualquer valor de tempo limite estabelecido para o domínio do aplicativo no qual o objeto Regex é criado. Se nenhum tempo limite for definido na chamada do construtor Regex ou nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.
Confira também
- NextMatch()
- linguagem de expressão regular – referência rápida
Aplica-se a
Match(String, String, RegexOptions)
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções de correspondência especificadas.
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
A cadeia de caracteres a ser pesquisada por uma correspondência.
- pattern
- String
O padrão de expressão regular a ser correspondido.
- options
- RegexOptions
Uma combinação bit a bit dos valores de enumeração que fornecem opções para correspondência.
Retornos
Um objeto que contém informações sobre a correspondência.
Exceções
Ocorreu um erro de análise de expressão regular.
input
ou pattern
é null
.
options
não é uma combinação bit a bit válida de valores RegexOptions.
Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.
Exemplos
O exemplo a seguir define uma expressão regular que corresponde às palavras que começam com a letra "a". Ele usa a opção RegexOptions.IgnoreCase para garantir que a expressão regular localize palavras começando com um "a" maiúsculo e um "a" minúsculo.
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.
O padrão de expressão regular \ba\w*\b
é interpretado conforme mostrado na tabela a seguir.
Padrão | Descrição |
---|---|
\b |
Inicie a correspondência em um limite de palavra. |
a |
Corresponda ao caractere "a". |
\w* |
Corresponder a zero, um ou mais caracteres de palavra. |
\b |
Encerre a correspondência em um limite de palavra. |
Comentários
O método Match(String, String, RegexOptions) retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular - Referência Rápida.
O método Match(String, String, RegexOptions) estático é equivalente a construir um objeto Regex com o construtor Regex(String, RegexOptions) e chamar a instância Match(String) método.
O parâmetro pattern
consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.
Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input
que corresponde ao padrão de expressão regular. Se nenhuma correspondência for encontrada, seu valor será String.Empty.
Esse método retorna a primeira subcadeia de caracteres encontrada em input
que corresponde ao padrão de expressão regular. Você pode recuperar correspondências subsequentes chamando repetidamente o método de NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String, RegexOptions).
A exceção RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado para o domínio do aplicativo no qual o método é chamado. Se nenhum tempo limite for definido nas propriedades do domínio do aplicativo ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será gerada.
Notas aos Chamadores
Esse método atinge o tempo limite após um intervalo igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado. Se um valor de tempo limite não tiver sido definido para o domínio do aplicativo, o valor InfiniteMatchTimeout, que impede o tempo limite do método, será usado. O método estático recomendado para recuperar uma correspondência de padrão é Match(String, String), o que permite definir o intervalo de tempo limite.
Confira também
- NextMatch()
- linguagem de expressão regular – referência rápida
Aplica-se a
Match(String, String, RegexOptions, TimeSpan)
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
- Origem:
- Regex.Match.cs
Pesquisa a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções de correspondência especificadas e o intervalo de tempo limite.
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
A cadeia de caracteres a ser pesquisada por uma correspondência.
- pattern
- String
O padrão de expressão regular a ser correspondido.
- options
- RegexOptions
Uma combinação bit a bit dos valores de enumeração que fornecem opções para correspondência.
- matchTimeout
- TimeSpan
Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve ter tempo limite.
Retornos
Um objeto que contém informações sobre a correspondência.
Exceções
Ocorreu um erro de análise de expressão regular.
input
ou pattern
é null
.
options
não é uma combinação bit a bit válida de valores RegexOptions.
-ou-
matchTimeout
é negativo, zero ou maior que aproximadamente 24 dias.
Ocorreu um tempo limite. Para obter mais informações sobre tempos limite, consulte a seção Comentários.
Comentários
O método Match(String, String, RegexOptions, TimeSpan) retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular em uma cadeia de caracteres de entrada. Para obter informações sobre os elementos de linguagem usados para criar um padrão de expressão regular, consulte Linguagem de Expressão Regular - Referência Rápida.
O método Match(String, String, RegexOptions, TimeSpan) estático é equivalente a construir um objeto Regex com o construtor Regex(String, RegexOptions, TimeSpan) e chamar a instância Match(String) método.
O parâmetro pattern
consiste em elementos de linguagem de expressão regular que descrevem simbolicamente a cadeia de caracteres a corresponder. Para obter mais informações sobre expressões regulares, consulte expressões regulares do .NET e Linguagem de Expressão Regular – Referência Rápida.
Você pode determinar se o padrão de expressão regular foi encontrado na cadeia de caracteres de entrada verificando o valor da propriedade Success do objeto Match retornado. Se uma correspondência for encontrada, a propriedade Value do objeto Match retornada conterá a subcadeia de caracteres de input
que corresponde ao padrão de expressão regular. Se nenhuma correspondência for encontrada, seu valor será String.Empty.
Esse método retorna a primeira subcadeia de caracteres encontrada em input
que corresponde ao padrão de expressão regular. Você pode recuperar correspondências subsequentes chamando repetidamente o método de NextMatch do objeto Match retornado. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String, RegexOptions).
O parâmetro matchTimeout
especifica por quanto tempo um método de correspondência de padrões deve tentar encontrar uma correspondência antes de atingir o tempo limite. A configuração de um intervalo de tempo limite impede que expressões regulares que dependem do retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas. Para obter mais informações, consulte práticas recomendadas para expressões regulares e backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método gerará uma exceção RegexMatchTimeoutException.
matchTimeout
substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.
Notas aos Chamadores
Recomendamos que você defina o parâmetro matchTimeout
como um valor apropriado, como dois segundos. Se você desabilitar o tempo limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferecerá um desempenho ligeiramente melhor. No entanto, você deve desabilitar os tempos limite apenas nas seguintes condições:
Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático. Isso exclui o texto que foi inserido dinamicamente pelos usuários.
Quando o padrão de expressão regular tiver sido testado minuciosamente para garantir que ele manipule com eficiência correspondências, não correspondências e correspondências próximas.
Quando o padrão de expressão regular não contém elementos de linguagem conhecidos por causar retrocesso excessivo ao processar uma correspondência próxima.
Confira também
- linguagem de expressão regular – referência rápida