Regex.Match Método

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

Public Function Match (input As String) As Match

Parâmetros

Retornos

Um objeto que contém informações sobre a correspondência.

Exceções

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.

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

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

Um objeto que contém informações sobre a correspondência.

Exceções

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

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

Um objeto que contém informações sobre a correspondência.

Exceções

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.

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

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

Um objeto que contém informações sobre a correspondência.

Exceções

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 ^, \Ge \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

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

Um objeto que contém informações sobre a correspondência.

Exceções

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.

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

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

Um objeto que contém informações sobre a correspondência.

Exceções

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