Partilhar via

Exemplo de expressão regular: Verificação de HREFs

O exemplo a seguir pesquisa uma cadeia de caracteres de entrada e exibe todos os href="..." e suas localizações na cadeia de caracteres.

Aviso

Ao usar System.Text.RegularExpressions para processar entradas não confiáveis, passe um tempo limite. Um usuário mal-intencionado pode fornecer entrada para RegularExpressionso , causando um ataque de Negação de Serviço. ASP.NET APIs da estrutura principal que usam RegularExpressions passar um tempo limite.

O objeto Regex

Como o DumpHRefs método pode ser chamado várias vezes a partir do código do usuário, ele usa o static método (Shared no Visual Basic). Regex.Match(String, String, RegexOptions) Isso permite que o mecanismo de expressão regular armazene em cache a expressão regular e evita a sobrecarga de instanciar um novo Regex objeto cada vez que o método é chamado. Um Match objeto é então usado para iterar através de todas as correspondências na cadeia de caracteres.

private static void DumpHRefs(string inputString)
{
    string hrefPattern = @"href\s*=\s*(?:[""'](?<1>[^""']*)[""']|(?<1>[^>\s]+))";

    try
    {
        Match regexMatch = Regex.Match(inputString, hrefPattern,
                                       RegexOptions.IgnoreCase | RegexOptions.Compiled,
                                       TimeSpan.FromSeconds(1));
        while (regexMatch.Success)
        {
            Console.WriteLine($"Found href {regexMatch.Groups[1]} at {regexMatch.Groups[1].Index}");
            regexMatch = regexMatch.NextMatch();
        }
    }
    catch (RegexMatchTimeoutException)
    {
        Console.WriteLine("The matching operation timed out.");
    }
}

Private Sub DumpHRefs(inputString As String)
    Dim hrefPattern As String = "href\s*=\s*(?:[""'](?<1>[^""']*)[""']|(?<1>[^>\s]+))"

    Try
        Dim regexMatch = Regex.Match(inputString, hrefPattern,
                                     RegexOptions.IgnoreCase Or RegexOptions.Compiled,
                                     TimeSpan.FromSeconds(1))
        Do While regexMatch.Success
            Console.WriteLine($"Found href {regexMatch.Groups(1)} at {regexMatch.Groups(1).Index}.")
            regexMatch = regexMatch.NextMatch()
        Loop
    Catch e As RegexMatchTimeoutException
        Console.WriteLine("The matching operation timed out.")
    End Try
End Sub

O exemplo a seguir ilustra uma chamada para o DumpHRefs método.

public static void Main()
{
    string inputString = "My favorite web sites include:</P>" +
                         "<A HREF=\"https://learn.microsoft.com/en-us/dotnet/\">" +
                         ".NET Documentation</A></P>" +
                         "<A HREF=\"http://www.microsoft.com\">" +
                         "Microsoft Corporation Home Page</A></P>" +
                         "<A HREF=\"https://devblogs.microsoft.com/dotnet/\">" +
                         ".NET Blog</A></P>";
    DumpHRefs(inputString);
}
// The example displays the following output:
//       Found href https://learn.microsoft.com/dotnet/ at 43
//       Found href http://www.microsoft.com at 114
//       Found href https://devblogs.microsoft.com/dotnet/ at 188

Public Sub Main()
    Dim inputString As String = "My favorite web sites include:</P>" &
                                "<A HREF=""https://learn.microsoft.com/en-us/dotnet/"">" &
                                ".NET Documentation</A></P>" &
                                "<A HREF=""http://www.microsoft.com"">" &
                                "Microsoft Corporation Home Page</A></P>" &
                                "<A HREF=""https://devblogs.microsoft.com/dotnet/"">" &
                                ".NET Blog</A></P>"
    DumpHRefs(inputString)
End Sub
' The example displays the following output:
'       Found href https://learn.microsoft.com/dotnet/ at 43
'       Found href http://www.microsoft.com at 114
'       Found href https://devblogs.microsoft.com/dotnet/ at 188

O padrão href\s*=\s*(?:["'](?<1>[^"']*)["']|(?<1>[^>\s]+)) de expressão regular é interpretado como mostrado na tabela a seguir.

Padrão Description
href Corresponda à string literal "href". A correspondência não diferencia maiúsculas de minúsculas.
\s* Corresponder a zero ou mais caracteres de espaço em branco.
= Corresponder ao sinal de igual.
\s* Corresponder a zero ou mais caracteres de espaço em branco.
(?: Inicie um grupo sem captura.
["'](?<1>[^"']*)["'] Corresponder a uma aspa ou apóstrofo, seguido por um grupo de captura que corresponda a qualquer caractere que não seja aspas ou apóstrofo, seguido por aspas ou apóstrofo. O grupo nomeado 1 está incluído neste padrão.
| Boolean OR que corresponde à expressão anterior ou à expressão seguinte.
(?<1>[^>\s]+) Um grupo de captura que usa um conjunto negado para corresponder a qualquer caractere que não seja um sinal maior que ou um caractere de espaço em branco. O grupo nomeado 1 está incluído neste padrão.
) Termine o grupo que não captura .

Classe de resultado da correspondência

Os resultados de uma pesquisa são armazenados na Match classe, que fornece acesso a todas as substrings extraídas pela pesquisa. Ele também se lembra da cadeia de caracteres que está sendo pesquisada e da expressão regular que está sendo usada, para que possa chamar o Match.NextMatch método para executar outra pesquisa começando onde a última terminou.

Capturas explicitamente nomeadas

Nas expressões regulares tradicionais, a captura de parênteses é numerada automaticamente sequencialmente. Isto levanta dois problemas. Primeiro, se uma expressão regular for modificada inserindo ou removendo um conjunto de parênteses, todo o código que se refere às capturas numeradas deve ser reescrito para refletir a nova numeração. Em segundo lugar, como diferentes conjuntos de parênteses geralmente são usados para fornecer duas expressões alternativas para uma correspondência aceitável, pode ser difícil determinar qual das duas expressões realmente retornou um resultado.

Para resolver esses problemas, a Regex classe suporta a sintaxe (?<name>…) para capturar uma correspondência em um slot especificado (o slot pode ser nomeado usando uma cadeia de caracteres ou um inteiro; inteiros podem ser recuperados mais rapidamente). Assim, correspondências alternativas para a mesma string podem ser direcionadas para o mesmo lugar. Em caso de conflito, a última partida que cai em um slot é a partida bem-sucedida. (No entanto, uma lista completa de várias correspondências para um único slot está disponível. Consulte a Group.Captures coleção para obter detalhes.)

Consulte também

  • Last updated on