Regex.Match Método

Definição

Pesquisa em uma cadeia de caracteres de entrada 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.Searches an input string for a substring that matches a regular expression pattern and returns the first occurrence as a single Match object.

Sobrecargas

Match(String, String, RegexOptions, TimeSpan)

Pesquisa a cadeia de caracteres de entrada da primeira ocorrência da expressão regular especificada, usando as opções de correspondência e intervalo de tempo limite especificados.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

Match(String, Int32, Int32)

Pesquisa a primeira ocorrência de uma expressão regular na cadeia de entrada, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

Match(String, String, RegexOptions)

Procura a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções especificadas de correspondência.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

Match(String, Int32)

Procura 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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

Match(String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada no construtor Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

Match(String, String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada.Searches the specified input string for the first occurrence of the specified regular expression.

Match(String, String, RegexOptions, TimeSpan)

Pesquisa a cadeia de caracteres de entrada da primeira ocorrência da expressão regular especificada, usando as opções de correspondência e intervalo de tempo limite especificados.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options and time-out interval.

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 na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

matchTimeout
TimeSpan

Um intervalo de tempo limite ou InfiniteMatchTimeout para indicar que o método não deve atingir o tempo limite.A time-out interval, or InfiniteMatchTimeout to indicate that the method should not time out.

Retornos

Um objeto que contém informações sobre a correspondência.An object that contains information about the match.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

input ou pattern é null.input or pattern is null.

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

- ou --or- matchTimeout é negativo, zero ou maior que aproximadamente 24 dias.matchTimeout is negative, zero, or greater than approximately 24 days.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

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.The Match(String, String, RegexOptions, TimeSpan) method returns the first substring that matches a regular expression pattern in an input string. 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.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

O método estático Match(String, String, RegexOptions, TimeSpan) é equivalente a construir um objeto Regex com o Construtor Regex(String, RegexOptions, TimeSpan) e chamar o método de Match(String) de instância.The static Match(String, String, RegexOptions, TimeSpan) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions, TimeSpan) constructor and calling the instance Match(String) method.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

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 de Match retornado.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se uma correspondência for encontrada, a propriedade Value do objeto de Match retornado conterá a subcadeia de input que corresponde ao padrão de expressão regular.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se nenhuma correspondência for encontrada, seu valor será String.Empty.If no match is found, its value is String.Empty.

Esse método retorna a primeira subcadeia de caracteres encontrada em input que corresponde ao padrão de expressão regular.This method returns the first substring found in input that matches the regular expression pattern. Você pode recuperar as correspondências subsequentes chamando repetidamente o método de NextMatch do objeto de Match retornado.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. 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).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

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 expirar. A definição de um intervalo de tempo limite impede que expressões regulares que dependem de retrocesso excessivo apareçam para parar de responder quando processam a entrada que contém correspondências próximas.The matchTimeout parameter specifies how long a pattern matching method should try to find a match before it times out. Setting a time-out interval prevents regular expressions that rely on excessive backtracking from appearing to stop responding when they process input that contains near matches. Para obter mais informações, consulte práticas recomendadas para expressões regulares e retrocesso.For more information, see Best Practices for Regular Expressions and Backtracking. Se nenhuma correspondência for encontrada nesse intervalo de tempo, o método lançará uma exceção de RegexMatchTimeoutException.If no match is found in that time interval, the method throws a RegexMatchTimeoutException exception. matchTimeout substitui qualquer valor de tempo limite padrão definido para o domínio do aplicativo no qual o método é executado.matchTimeout overrides any default time-out value defined for the application domain in which the method executes.

Notas aos Chamadores

Recomendamos que você defina o parâmetro matchTimeout para um valor apropriado, como dois segundos.We recommend that you set the matchTimeout parameter to an appropriate value, such as two seconds. Se você desabilitar os tempos limite especificando InfiniteMatchTimeout, o mecanismo de expressão regular oferece um desempenho ligeiramente melhor.If you disable time-outs by specifying InfiniteMatchTimeout, the regular expression engine offers slightly better performance. No entanto, você deve desabilitar o tempo limite somente sob as seguintes condições:However, you should disable time-outs only under the following conditions: -Quando a entrada processada por uma expressão regular é derivada de uma fonte conhecida e confiável ou consiste em texto estático.- When the input processed by a regular expression is derived from a known and trusted source or consists of static text. Isso exclui o texto que foi inserido dinamicamente pelos usuários.This excludes text that has been dynamically input by users.

-Quando o padrão de expressão regular foi totalmente testado para garantir que ele lide com as correspondências, não correspondentes e correspondências próximas.- When the regular expression pattern has been thoroughly tested to ensure that it efficiently handles matches, non-matches, and near matches.

-Quando o padrão de expressão regular não contém nenhum elemento de linguagem que seja conhecido por causar um retrocesso excessivo ao processar uma correspondência próxima.- When the regular expression pattern contains no language elements that are known to cause excessive backtracking when processing a near match.

Veja também

Match(String, Int32, Int32)

Pesquisa a primeira ocorrência de uma expressão regular na cadeia de entrada, começando na posição inicial especificada e pesquisando apenas o número especificado de caracteres.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position and searching only the specified number of characters.

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 na qual será pesquisada uma correspondência.The string to search for a match.

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.The zero-based character position in the input string that defines the leftmost position to be searched.

length
Int32

O número de caracteres na subcadeia de caracteres a ser incluído na pesquisa.The number of characters in the substring to include in the search.

Retornos

Um objeto que contém informações sobre a correspondência.An object that contains information about the match.

Exceções

input é null.input is null.

beginning é menor que zero ou maior que o tamanho de input.beginning is less than zero or greater than the length of input.

- ou --or- length é menor que zero ou maior que o tamanho de input.length is less than zero or greater than the length of input.

- ou --or- beginning+length-1 identifica uma posição que está fora do intervalo de input.beginning+length-1 identifies a position that is outside the range of input.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

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.The Match(String, Int32, Int32) method returns the first substring that matches a regular expression pattern in a portion of an input string. 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.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

O padrão de expressão regular para o qual o método de Match(String, Int32, Int32) pesquisa é definido pela chamada para um dos construtores de classe Regex.The regular expression pattern for which the Match(String, Int32, Int32) method searches is defined by the call to one of the Regex class constructors. 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.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

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.The Match(String, Int32, Int32) method searches the portion of input defined by the beginning and length parameters for the regular expression pattern. beginning sempre define o índice do caractere mais à esquerda para incluir na pesquisa e length define o número máximo de caracteres a serem pesquisados.beginning always defines the index of the leftmost character to include in the search, and length defines the maximum number of characters to search. Juntos, eles definem o intervalo da pesquisa.Together, they define the range of the search. Se a pesquisa continuar da esquerda para a direita (o padrão), o mecanismo de expressão regular pesquisará o caractere no índice beginning para o caractere no índice beginning + length-1.If the search proceeds from left to right (the default), the regular expression engine searches from the character at index beginning to the character at index beginning + length - 1. Se o mecanismo de expressões regulares tiver sido instanciado usando a opção RegexOptions.RightToLeft para que a pesquisa prossiga da direita para a esquerda, o mecanismo de expressões regulares pesquisará o caractere no índice beginning + length-1 para o caractere no índice beginning.If the regular expression engine was instantiated by using the RegexOptions.RightToLeft option so that the search proceeds from right to left, the regular expression engine searches from the character at index beginning + length - 1 to the character at index beginning. Esse método retorna a primeira correspondência que encontra dentro desse intervalo.This method returns the first match that it finds within this range. Você pode recuperar as correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto de Match retornado.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method.

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 de Match retornado.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se uma correspondência for encontrada, a propriedade Value do objeto de Match retornado conterá a subcadeia de input que corresponde ao padrão de expressão regular.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se nenhuma correspondência for encontrada, seu valor será String.Empty.If no match is found, its value is String.Empty.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 de Regex é criado.If you do not set a time-out value when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Veja também

Match(String, String, RegexOptions)

Procura a cadeia de caracteres de entrada para a primeira ocorrência da expressão regular especificada, usando as opções especificadas de correspondência.Searches the input string for the first occurrence of the specified regular expression, using the specified matching options.

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 na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

options
RegexOptions

Uma combinação bit a bit dos valores de enumeração que fornece opções para correspondência.A bitwise combination of the enumeration values that provide options for matching.

Retornos

Um objeto que contém informações sobre a correspondência.An object that contains information about the match.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

input ou pattern é null.input or pattern is null.

options não é uma combinação bit a bit válida de valores de RegexOptions.options is not a valid bitwise combination of RegexOptions values.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir define uma expressão regular que corresponde às palavras que começam com a letra "a".The following example defines a regular expression that matches words beginning with the letter "a". Ele usa a opção RegexOptions.IgnoreCase para garantir que a expressão regular Localize palavras que comecem com letras maiúsculas "a" e minúsculas "a".It uses the RegexOptions.IgnoreCase option to ensure that the regular expression locates words beginning with both an uppercase "a" and a lowercase "a".

using System;
using System.Text.RegularExpressions;

public class Example
{
   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 da expressão regular \ba\w*\b é interpretado conforme mostrado na tabela a seguir.The regular expression pattern \ba\w*\b is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
a Corresponder ao caractere "a".Match the character "a".
\w* Corresponder zero, um ou mais caracteres de palavra.Match zero, one, or more word characters.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

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.The Match(String, String, RegexOptions) method returns the first substring that matches a regular expression pattern in an input string. 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.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

O método estático Match(String, String, RegexOptions) é equivalente a construir um objeto Regex com o Construtor Regex(String, RegexOptions) e chamar o método de Match(String) de instância.The static Match(String, String, RegexOptions) method is equivalent to constructing a Regex object with the Regex(String, RegexOptions) constructor and calling the instance Match(String) method.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

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 de Match retornado.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se uma correspondência for encontrada, a propriedade Value do objeto de Match retornado conterá a subcadeia de input que corresponde ao padrão de expressão regular.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se nenhuma correspondência for encontrada, seu valor será String.Empty.If no match is found, its value is String.Empty.

Esse método retorna a primeira subcadeia de caracteres encontrada em input que corresponde ao padrão de expressão regular.This method returns the first substring found in input that matches the regular expression pattern. Você pode recuperar as correspondências subsequentes chamando repetidamente o método de NextMatch do objeto de Match retornado.You can retrieve subsequent matches by repeatedly calling the returned Match object's NextMatch method. 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).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String, RegexOptions) method.

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.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. 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á lançada.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. 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.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. O método estático recomendado para recuperar uma correspondência de padrão é Match(String, String), o que permite que você defina o intervalo de tempo limite.The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

Veja também

Match(String, Int32)

Procura 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.Searches the input string for the first occurrence of a regular expression, beginning at the specified starting position in the string.

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 na qual será pesquisada uma correspondência.The string to search for a match.

startat
Int32

A posição do caractere baseada em zero na qual iniciar a pesquisa.The zero-based character position at which to start the search.

Retornos

Um objeto que contém informações sobre a correspondência.An object that contains information about the match.

Exceções

input é null.input is null.

startat é menor que zero ou maior que o tamanho de input.startat is less than zero or greater than the length of input.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Comentários

O método Match(String, Int32) retorna a primeira subcadeia de caracteres que corresponde a um padrão de expressão regular, começando em ou após a posição do caractere startat, em uma cadeia de caracteres de entrada.The Match(String, Int32) method returns the first substring that matches a regular expression pattern, starting at or after the startat character position, in an input string. 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.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

O padrão de expressão regular para o qual o método de Match(String, Int32) pesquisa é definido pela chamada para um dos construtores de classe Regex.The regular expression pattern for which the Match(String, Int32) method searches is defined by the call to one of the Regex class constructors. 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.For more information about the elements that can form a regular expression pattern, see Regular Expression Language - Quick Reference.

Opcionalmente, você pode especificar uma posição inicial na cadeia de caracteres usando o parâmetro startat.You can optionally specify a starting position in the string by using the startat parameter. Quando o mecanismo de expressão regular é analisado da esquerda para a direita (o padrão), a correspondência e a verificação movem rightward, começando com o caractere especificado em startat.When the regular expression engine parses from left to right (the default), the match and the scan move rightward, starting at the character specified in startat. Quando o mecanismo de expressão regular é analisado da direita para a esquerda (quando o padrão de expressão regular é construído com a opção RegexOptions.RightToLeft), a correspondência e a digitalização são movidas na direção oposta e começam com o caractere em startat-1.When the regular expression engine parses from right to left (when the regular expression pattern is constructed with the RegexOptions.RightToLeft option), the match and scan move in the opposite direction and begin with the character at startat -1. Se você não especificar uma posição inicial, a pesquisa começará na posição de startat padrão.If you do not specify a starting position, the search begins at the default startat position. Se a expressão regular for pesquisa da esquerda para a direita, a posição de startat padrão estará na extremidade esquerda de input; Se ele Pesquisar da direita para a esquerda, a posição de startat padrão estará na extremidade direita de input.If the regular expression searches from left to right, the default startat position is at the left end of input; if it searches from right to left, the default startat position is at the right end of input.

Se você quiser restringir uma correspondência para que ela comece em uma posição de caractere específica na cadeia de caracteres e o mecanismo de expressão regular não verifique o restante da cadeia de caracteres para uma correspondência, ancorar a expressão regular com uma \G (à esquerda para um padrão da esquerda para a direita ou à direita para um padrão da direita para a esquerda).If you want to restrict a match so that it begins at a particular character position in the string and the regular expression engine does not scan the remainder of the string for a match, anchor the regular expression with a \G (at the left for a left-to-right pattern, or at the right for a right-to-left pattern). Isso restringe a correspondência para que ela deva ser iniciada exatamente em startat.This restricts the match so it must start exactly at startat.

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 de Match retornado.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se uma correspondência for encontrada, a propriedade Value do objeto de Match retornado conterá a subcadeia de input que corresponde ao padrão de expressão regular.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se nenhuma correspondência for encontrada, seu valor será String.Empty.If no match is found, its value is String.Empty.

Esse método retorna a primeira subcadeia de caracteres encontrada em ou após a startat posição de caractere em input que corresponde ao padrão de expressão regular.This method returns the first substring found at or after the startat character position in input that matches the regular expression pattern. Você pode recuperar as correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto de Match retornado.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, Int32).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, Int32) method.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 de Regex é criado.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Veja também

Match(String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada no construtor Regex.Searches the specified input string for the first occurrence of the regular expression specified in the Regex constructor.

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 na qual será pesquisada uma correspondência.The string to search for a match.

Retornos

Um objeto que contém informações sobre a correspondência.An object that contains information about the match.

Exceções

input é null.input is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

Exemplos

O exemplo a seguir localiza correspondências padrão de expressão regular em uma cadeia de caracteres e lista os grupos correspondentes, captura e posições de captura.The following example finds regular expression pattern matches in a string, then lists the matched groups, captures, and capture positions.

#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 a ocorrências da palavra "Car" junto com a palavra que a precede.The regular expression pattern (\w+)\s+(car) matches occurrences of the word "car" along with the word that precedes it. Ele é interpretado conforme mostrado na tabela a seguir.It is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
(\w+) Corresponde a um ou mais caracteres de palavra.Match one or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
\s+ Corresponder um ou mais caracteres de espaço em branco.Match one or more white-space characters.
carro(car) Corresponder à cadeia de caracteres literal "Car".Match the literal string "car". Este é o segundo grupo de captura.This is the second capturing group.

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.The Match(String) method returns the first substring that matches a regular expression pattern in an input string. 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.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

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 de Match retornado.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se uma correspondência for encontrada, a propriedade Value do objeto de Match retornado conterá a subcadeia de input que corresponde ao padrão de expressão regular.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se nenhuma correspondência for encontrada, seu valor será String.Empty.If no match is found, its value is String.Empty.

Esse método retorna a primeira subcadeia de caracteres em input que corresponde ao padrão de expressão regular.This method returns the first substring in input that matches the regular expression pattern. Você pode recuperar as correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto de Match retornado.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String).You can also retrieve all matches in a single method call by calling the Regex.Matches(String) method.

A exceção de RegexMatchTimeoutException será gerada se o tempo de execução da operação de correspondência exceder o intervalo de tempo limite especificado pelo construtor de Regex.Regex(String, RegexOptions, TimeSpan).The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified by the Regex.Regex(String, RegexOptions, TimeSpan) constructor. 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 de Regex é criado.If you do not set a time-out interval when you call the constructor, the exception is thrown if the operation exceeds any time-out value established for the application domain in which the Regex object is created. Se nenhum tempo limite for definido na chamada de construtor de Regex ou nas propriedades do domínio do aplicativo, ou se o valor de tempo limite for Regex.InfiniteMatchTimeout, nenhuma exceção será lançada.If no time-out is defined in the Regex constructor call or in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Veja também

Match(String, String)

Pesquisa a primeira ocorrência da expressão regular especificada na cadeia de caracteres de entrada especificada.Searches the specified input string for the first occurrence of the specified regular expression.

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 na qual será pesquisada uma correspondência.The string to search for a match.

pattern
String

O padrão de expressão regular para correspondência.The regular expression pattern to match.

Retornos

Um objeto que contém informações sobre a correspondência.An object that contains information about the match.

Exceções

Ocorreu um erro de análise da expressão regular.A regular expression parsing error occurred.

input ou pattern é null.input or pattern is null.

Ocorreu um tempo limite.A time-out occurred. Para obter mais informações sobre tempos limite, consulte a seção Comentários.For more information about time-outs, see the Remarks section.

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.The following example calls the Match(String, String) method to find the first word that contains at least one z character, and then calls the Match.NextMatch method to find any additional matches.

using System;
using System.Text.RegularExpressions;

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 da expressão regular \b\w*z+\w*\b é interpretado conforme mostrado na tabela a seguir.The regular expression pattern \b\w*z+\w*\b is interpreted as shown in the following table.

PadrãoPattern DescriçãoDescription
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
\w* Corresponder zero, um ou mais caracteres de palavra.Match zero, one, or more word characters.
z+ Corresponder a uma ou mais ocorrências do caractere de z.Match one or more occurrences of the z character.
\w* Corresponder zero, um ou mais caracteres de palavra.Match zero, one, or more word characters.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

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.The Match(String, String) method returns the first substring that matches a regular expression pattern in an input string. 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.For information about the language elements used to build a regular expression pattern, see Regular Expression Language - Quick Reference.

O método estático Match(String, String) é equivalente a construir um objeto Regex com o padrão de expressão regular especificado e chamar o método de Match(String) de instância.The static Match(String, String) method is equivalent to constructing a Regex object with the specified regular expression pattern and calling the instance Match(String) method. Nesse caso, o mecanismo de expressões regulares armazena em cache o padrão de expressão regular.In this case, the regular expression engine caches the regular expression pattern.

O parâmetro pattern consiste em elementos de linguagem de expressão regular que descrevem de forma simbólica a cadeia de caracteres a ser correspondida.The pattern parameter consists of regular expression language elements that symbolically describe the string to match. Para obter mais informações sobre expressões regulares, consulte .NET Framework expressões regulares e linguagem de expressão regular-referência rápida.For more information about regular expressions, see .NET Framework Regular Expressions and Regular Expression Language - Quick Reference.

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 de Match retornado.You can determine whether the regular expression pattern has been found in the input string by checking the value of the returned Match object's Success property. Se uma correspondência for encontrada, a propriedade Value do objeto de Match retornado conterá a subcadeia de input que corresponde ao padrão de expressão regular.If a match is found, the returned Match object's Value property contains the substring from input that matches the regular expression pattern. Se nenhuma correspondência for encontrada, seu valor será String.Empty.If no match is found, its value is String.Empty.

Esse método retorna a primeira subcadeia de caracteres em input que corresponde ao padrão de expressão regular.This method returns the first substring in input that matches the regular expression pattern. Você pode recuperar as correspondências subsequentes chamando repetidamente o método de Match.NextMatch do objeto de Match retornado.You can retrieve subsequent matches by repeatedly calling the returned Match object's Match.NextMatch method. Você também pode recuperar todas as correspondências em uma única chamada de método chamando o método Regex.Matches(String, String).You can also retrieve all matches in a single method call by calling the Regex.Matches(String, String) method.

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.The RegexMatchTimeoutException exception is thrown if the execution time of the matching operation exceeds the time-out interval specified for the application domain in which the method is called. 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á lançada.If no time-out is defined in the application domain's properties, or if the time-out value is Regex.InfiniteMatchTimeout, no exception is thrown.

Notas aos Chamadores

Esse método atinge o tempo limite após um intervalo que é igual ao valor de tempo limite padrão do domínio do aplicativo no qual ele é chamado.This method times out after an interval that is equal to the default time-out value of the application domain in which it is called. 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.If a time-out value has not been defined for the application domain, the value InfiniteMatchTimeout, which prevents the method from timing out, is used. O método estático recomendado para recuperar uma correspondência de padrão é Match(String, String), o que permite que você defina o intervalo de tempo limite.The recommended static method for retrieving a pattern match is Match(String, String), which lets you set the time-out interval.

Veja também

Aplica-se a