Regex.IsMatch Método

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Exemplos

O exemplo a seguir ilustra o uso do método IsMatch(String, String, RegexOptions, TimeSpan) para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico. A correspondência do padrão de expressão regular deve envolver pesquisa mínima por meio da cadeia de caracteres de entrada, de modo que o método define um intervalo de tempo limite de 500 milissegundos.

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468a",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
foreach (string partNumber in partNumbers)
    try
    {
        bool isMatch = Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(500));
        Console.WriteLine($"{partNumber} {(isMatch ? "is" : "is not")} a valid part number.");
    }
    catch (RegexMatchTimeoutException e)
    {
        Console.WriteLine($"Timeout after {e.MatchTimeout} seconds matching {e.Input}.");
    }

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468a", 
                                      "_A90-123-129X", "12345-KKA-1230", 
                                      "0919-2893-1256" }
      Dim pattern As String = "^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$"
      For Each partNumber As String In partNumbers
         Try
            Console.WriteLine("{0} {1} a valid part number.", 
                              partNumber, _
                              IIF(Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase), _
                                  "is", "is not"),
                              TimeSpan.FromMilliseconds(500))
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("Timeout after {0} seconds matching {1}.",
                              e.MatchTimeout, e.Input)
         End Try
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468a is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

O padrão de expressão regular é:

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Chamar o método IsMatch(String, String, RegexOptions, TimeSpan) com o parâmetro options definido como RegexOptions.IgnoreCase é equivalente a definir a seguinte expressão regular:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]

Para comparação, consulte o exemplo do método IsMatch(String, String).

Comentários

O método IsMatch normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e recuperá-las para manipulação subsequente, chame o método Match ou Matches.

O método de IsMatch(String, String, RegexOptions, TimeSpan) estático é equivalente à construção de um objeto Regex com o padrão de expressão regular especificado por pattern e as opções de expressão regular especificadas por options e chamando o método de instância IsMatch(String). Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo 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.

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

• elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static bool IsMatch(ReadOnlySpan<char> input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static bool IsMatch (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member IsMatch : ReadOnlySpan<char> * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> bool

Public Shared Function IsMatch (input As ReadOnlySpan(Of Char), pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

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

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

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

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

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Exemplos

O exemplo a seguir ilustra o uso do método IsMatch(String, String) para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468a",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
string pattern = @"^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$";
foreach (string partNumber in partNumbers)
    Console.WriteLine("{0} {1} a valid part number.",
                      partNumber,
                      Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase) ? "is" : "is not");

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468a is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468a", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim pattern As String = "^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$"
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(Regex.IsMatch(partNumber, pattern, RegexOptions.IgnoreCase), _
                               "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468a is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

O padrão de expressão regular é:

^[A-Z0-9]\d{2}[A-Z0-9](-\d{3}){2}[A-Z0-9]$

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Chamar o método IsMatch(String, String, RegexOptions) com o parâmetro options definido como RegexOptions.IgnoreCase é equivalente a definir a seguinte expressão regular:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]

Para comparação, consulte o exemplo do método IsMatch(String, String).

Comentários

O método IsMatch normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e recuperá-las para manipulação subsequente, chame o método Match ou Matches.

O método de IsMatch(String, String, RegexOptions) estático é equivalente à construção de um objeto Regex com o padrão de expressão regular especificado por pattern e as opções de expressão regular especificadas por options e chamando o método de instância IsMatch(String). Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo 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.

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 verificar se uma correspondência de padrão é IsMatch(String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

• elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static bool IsMatch(ReadOnlySpan<char> input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static bool IsMatch (ReadOnlySpan<char> input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member IsMatch : ReadOnlySpan<char> * string * System.Text.RegularExpressions.RegexOptions -> bool

Public Shared Function IsMatch (input As ReadOnlySpan(Of Char), pattern As String, options As RegexOptions) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static bool IsMatch(System::String ^ input, System::String ^ pattern);

public static bool IsMatch (string input, string pattern);

static member IsMatch : string * string -> bool

Public Shared Function IsMatch (input As String, pattern As String) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Exemplos

O exemplo a seguir ilustra o uso do método IsMatch(String, String) para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468A",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
string pattern = @"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$";
foreach (string partNumber in partNumbers)
    Console.WriteLine($"{partNumber} {(Regex.IsMatch(partNumber, pattern) ? "is" : "is not")} " +
        $"a valid part number.");

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468A", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim pattern As String = "^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$"
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(Regex.IsMatch(partNumber, pattern), "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468A is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

O padrão de expressão regular é:

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Comentários

O método IsMatch normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e recuperá-las para manipulação subsequente, chame o método Match ou Matches.

O método de IsMatch(String, String) estático é equivalente à construção de um objeto Regex com o padrão de expressão regular especificado por pattern e chamando o método de instância IsMatch(String). Esse padrão de expressão regular é armazenado em cache para recuperação rápida pelo mecanismo 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.

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 o método é 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 verificar se uma correspondência de padrão é IsMatch(String, String, RegexOptions, TimeSpan), o que permite definir o intervalo de tempo limite.

Confira também

• elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 bool IsMatch(ReadOnlySpan<char> input, int startat);

public bool IsMatch (ReadOnlySpan<char> input, int startat);

member this.IsMatch : ReadOnlySpan<char> * int -> bool

Public Function IsMatch (input As ReadOnlySpan(Of Char), startat As Integer) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 static bool IsMatch(ReadOnlySpan<char> input, System::String ^ pattern);

public static bool IsMatch (ReadOnlySpan<char> input, string pattern);

static member IsMatch : ReadOnlySpan<char> * string -> bool

Public Shared Function IsMatch (input As ReadOnlySpan(Of Char), pattern As String) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 bool IsMatch(System::String ^ input, int startat);

public bool IsMatch (string input, int startat);

member this.IsMatch : string * int -> bool

Public Function IsMatch (input As String, startat As Integer) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Exemplos

O exemplo a seguir ilustra o uso do método IsMatch(String, Int32) para determinar se uma cadeia de caracteres é um número de parte válido. Ele procura um número de parte que segue dois-pontos (:) caractere em uma cadeia de caracteres. O método IndexOf(Char) é usado para determinar a posição do caractere de dois-pontos, que é então passado para o método IsMatch(String, Int32). A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

string[] partNumbers = [ "Part Number: 1298-673-4192", "Part No: A08Z-931-468A",
                      "_A90-123-129X", "123K-000-1230",
                      "SKU: 0919-2893-1256" ];
Regex rgx = MyRegex();
foreach (string partNumber in partNumbers)
{
    int start = partNumber.IndexOf(':');
    if (start >= 0)
    {
        Console.WriteLine($"{partNumber} {(rgx.IsMatch(partNumber, start) ? "is" : "is not")} a valid part number.");
    }
    else
    {
        Console.WriteLine("Cannot find starting position in {0}.", partNumber);
    }
}

// The example displays the following output:
//       Part Number: 1298-673-4192 is a valid part number.
//       Part No: A08Z-931-468A is a valid part number.
//       Cannot find starting position in _A90-123-129X.
//       Cannot find starting position in 123K-000-1230.
//       SKU: 0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "Part Number: 1298-673-4192", "Part No: A08Z-931-468A", _
                                      "_A90-123-129X", "123K-000-1230", _
                                      "SKU: 0919-2893-1256" }
      Dim rgx As New Regex("[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$")
      For Each partNumber As String In partNumbers
         Dim start As Integer = partNumber.IndexOf(":"c)
         If start >= 0 Then 
            Console.WriteLine("{0} {1} a valid part number.", _
                              partNumber, _
                              IIF(rgx.IsMatch(partNumber, start), "is", "is not"))
         Else
            Console.WriteLine("Cannot find starting position in {0}.", partNumber)
         End If                              
      Next
   End Sub
End Module
' The example displays the following output:
'       Part Number: 1298-673-4192 is a valid part number.
'       Part No: A08Z-931-468A is a valid part number.
'       Cannot find starting position in _A90-123-129X.
'       Cannot find starting position in 123K-000-1230.
'       SKU: 0919-2893-1256 is not a valid part number.

O padrão de expressão regular é:

[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Comentários

O método IsMatch normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e recuperá-las para manipulação subsequente, chame o método Match ou Matches.

Para obter mais detalhes sobre startat, consulte a seção Comentários do Match(String, Int32).

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

• elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 bool IsMatch(System::String ^ input);

public bool IsMatch (string input);

member this.IsMatch : string -> bool

Public Function IsMatch (input As String) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções

Exemplos

O exemplo a seguir ilustra o uso do método IsMatch(String) para determinar se uma cadeia de caracteres é um número de parte válido. A expressão regular pressupõe que o número da parte tenha um formato específico que consiste em três conjuntos de caracteres separados por hifens. O primeiro conjunto, que contém quatro caracteres, deve consistir em um caractere alfanumérico seguido por dois caracteres numéricos seguidos por um caractere alfanumérico. O segundo conjunto, que consiste em três caracteres, deve ser numérico. O terceiro conjunto, que consiste em quatro caracteres, deve ter três caracteres numéricos seguidos por um caractere alfanumérico.

string[] partNumbers = [ "1298-673-4192", "A08Z-931-468A",
                      "_A90-123-129X", "12345-KKA-1230",
                      "0919-2893-1256" ];
Regex rgx = new Regex(@"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$");
foreach (string partNumber in partNumbers)
    Console.WriteLine($"{partNumber} {(rgx.IsMatch(partNumber) ? "is" : "is not")} a valid part number.");

// The example displays the following output:
//       1298-673-4192 is a valid part number.
//       A08Z-931-468A is a valid part number.
//       _A90-123-129X is not a valid part number.
//       12345-KKA-1230 is not a valid part number.
//       0919-2893-1256 is not a valid part number.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim partNumbers() As String = { "1298-673-4192", "A08Z-931-468A", _
                                      "_A90-123-129X", "12345-KKA-1230", _
                                      "0919-2893-1256" }
      Dim rgx As New Regex("^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$")
      For Each partNumber As String In partNumbers
         Console.WriteLine("{0} {1} a valid part number.", _
                           partNumber, _
                           IIF(rgx.IsMatch(partNumber), "is", "is not"))
      Next
   End Sub
End Module
' The example displays the following output:
'       1298-673-4192 is a valid part number.
'       A08Z-931-468A is a valid part number.
'       _A90-123-129X is not a valid part number.
'       12345-KKA-1230 is not a valid part number.
'       0919-2893-1256 is not a valid part number.

O padrão de expressão regular é:

^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$

A tabela a seguir mostra como o padrão de expressão regular é interpretado.

Comentários

O método IsMatch normalmente é usado para validar uma cadeia de caracteres ou para garantir que uma cadeia de caracteres esteja em conformidade com um padrão específico sem recuperar essa cadeia de caracteres para manipulação subsequente. Se você quiser determinar se uma ou mais cadeias de caracteres correspondem a um padrão de expressão regular e recuperá-las para manipulação subsequente, chame o método Match ou Matches.

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

• elementos de linguagem de expressão regular

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

Origem:

Regex.Match.cs

public:
 bool IsMatch(ReadOnlySpan<char> input);

public bool IsMatch (ReadOnlySpan<char> input);

member this.IsMatch : ReadOnlySpan<char> -> bool

Public Function IsMatch (input As ReadOnlySpan(Of Char)) As Boolean

Parâmetros

Retornos

true se a expressão regular encontrar uma correspondência; caso contrário, false.

Exceções