Ejemplo de expresiones regulares: Buscar etiquetas HREF

En el ejemplo siguiente se busca una cadena de entrada y se muestran todos los href="..." valores y sus ubicaciones en la cadena.

Objeto Regex

Dado que el DumpHRefs método se puede llamar varias veces desde el código de usuario, usa el static método (Shared en Visual Basic). Regex.Match(String, String, RegexOptions) Esto permite al motor de expresiones regulares almacenar en caché la expresión regular y evitar la sobrecarga de crear instancias de un nuevo Regex objeto cada vez que se llama al método . A continuación, se usa un Match objeto para recorrer en iteración todas las coincidencias de la cadena.

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

A continuación, en el ejemplo siguiente se muestra una llamada al 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

El patrón de la expresión regular href\s*=\s*(?:["'](?<1>[^"']*)["']|(?<1>[^>\s]+)) se interpreta como se muestra en la tabla siguiente.

Clase de resultado de coincidencia

Los resultados de una búsqueda se almacenan en la Match clase , que proporciona acceso a todas las subcadenas extraídas por la búsqueda. También recuerda la cadena que se está buscando y la expresión regular que se está usando, por lo que puede llamar al método Match.NextMatch para realizar otra búsqueda empezando donde terminó la última.

Capturas con nombre explícito

En las expresiones regulares tradicionales, los paréntesis de captura se numeran automáticamente de forma secuencial. Esto conduce a dos problemas. En primer lugar, si se modifica una expresión regular insertando o quitando un conjunto de paréntesis, todo el código que hace referencia a las capturas numeradas se debe volver a escribir para reflejar la nueva numeración. En segundo lugar, dado que a menudo se usan diferentes conjuntos de paréntesis para proporcionar dos expresiones alternativas para una coincidencia aceptable, podría ser difícil determinar cuál de las dos expresiones devolvió realmente un resultado.

Para solucionar estos problemas, la Regex clase admite la sintaxis (?<name>…) para capturar una coincidencia en una ranura especificada (la ranura se puede denominar mediante una cadena o un entero; los enteros se pueden recuperar más rápidamente). Así, las coincidencias alternativas para la misma cadena se pueden dirigir todas al mismo lugar. En caso de conflicto, la última coincidencia situada en la ranura es la coincidencia correcta. (Sin embargo, existe una lista completa de coincidencias múltiples para una sola ranura. Consulte la colección Group.Captures para más detalles).

Consulte también

• Expresiones regulares de .NET