Comparteix a través de

Anclajes en expresiones regulares

Los delimitadores, o aserciones atómicas de ancho cero, especifican una posición en la cadena donde debe producirse una coincidencia. Cuando se usa un delimitador en la expresión de búsqueda, el motor de expresiones regulares no avanza a través de la cadena ni consume caracteres; busca una coincidencia solo en la posición especificada. Por ejemplo, ^ especifica que la coincidencia debe comenzar al principio de una línea o cadena. Por lo tanto, la expresión ^http: regular coincide con "http:" solo cuando se produce al principio de una línea. En la tabla siguiente se enumeran los delimitadores admitidos por las expresiones regulares de .NET.

Anchor Descripción
^ De forma predeterminada, la coincidencia debe producirse al principio de la cadena; en modo multilínea, debe producirse al principio de la línea. Para obtener más información, vea Inicio de cadena o línea.
$ De forma predeterminada, la coincidencia debe producirse al final de la cadena o antes \n al final de la cadena; en modo multilínea, debe producirse al final de la línea o antes \n del final de la línea. Para obtener más información, vea Fin de cadena o línea.
\A La coincidencia debe producirse solo al principio de la cadena (sin soporte para varias líneas). Para obtener más información, vea Solo al inicio de la cadena.
\Z La coincidencia debe producirse al final de la cadena o antes del \n final de la cadena. Para obtener más información, vea Fin de cadena o Antes de finalizar nueva línea.
\z Debe producirse la coincidencia solo al final de la cadena. Para obtener más información, vea Solo fin de cadena.
\G La coincidencia debe comenzar en la posición en la que finalizó la coincidencia anterior, o si no había ninguna coincidencia anterior, en la posición de la cadena donde se inició la coincidencia. Para obtener más información, vea Coincidencias contiguas.
\b La coincidencia debe producirse en un límite de palabras. Para obtener más información, vea Word Boundary.
\B La coincidencia no debe producirse en un límite de palabras. Para obtener más información, vea Non-Word Boundary.

Inicio de cadena o línea: ^

De forma predeterminada, el ^ ancla especifica que el siguiente patrón debe comenzar en la posición del primer carácter de la cadena. Si usa ^ con la RegexOptions.Multiline opción (vea Opciones de expresión regular), la coincidencia debe producirse al principio de cada línea.

En el ejemplo siguiente se usa el ^ delimitador en una expresión regular que extrae información sobre los años durante los que existían algunos equipos profesionales de béisbol. El ejemplo llama a dos sobrecargas del método Regex.Matches.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
                     "Chicago Cubs, National League, 1903-present\n" +
                     "Detroit Tigers, American League, 1901-present\n" +
                     "New York Giants, National League, 1885-1957\n" +
                     "Washington Senators, American League, 1901-1960\n";
        string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
        Match match;

        match = Regex.Match(input, pattern);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
                              "Chicago Cubs, National League, 1903-present" + vbCrLf +
                              "Detroit Tigers, American League, 1901-present" + vbCrLf +
                              "New York Giants, National League, 1885-1957" + vbCrLf +
                              "Washington Senators, American League, 1901-1960" + vbCrLf

        Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
        Dim match As Match

        match = Regex.Match(input, pattern)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.

El patrón de expresión regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ se define como se muestra en la tabla siguiente.

Modelo Descripción
^ Comience la coincidencia al inicio de la cadena de entrada (o al inicio de la línea si se llama al método con la opción RegexOptions.Multiline).
((\w+(\s?)){2,} Coincide con uno o varios caracteres de palabra seguidos de cero o de un espacio al menos dos veces. Este es el primer grupo de captura. Esta expresión también define un segundo y tercer grupo de captura: el segundo consta de la palabra capturada y la tercera consta del espacio en blanco capturado.
,\s Coincide con una coma seguida de un carácter de espacio en blanco.
(\w+\s\w+) Coincide con uno o varios caracteres de palabra seguidos de un espacio, seguidos de uno o más caracteres de palabra. Este es el cuarto grupo de captura.
, Coincidir con una coma.
\s\d{4} Coincide con un espacio seguido de cuatro dígitos decimales.
(-(\d{4}|present))? Coincide con cero o una aparición de un guión seguido de cuatro dígitos decimales o la cadena "present". Este es el sexto grupo de captura. También incluye un séptimo grupo de captura.
,? Concuerda con cero o una coma.
(\s\d{4}(-(\d{4}|present))?,?)+ Coincide con una o varias apariciones de lo siguiente: un espacio, cuatro dígitos decimales, cero o una aparición de un guión seguido de cuatro dígitos decimales o la cadena "present" y cero o una coma. Este es el quinto grupo de captura.

Fin de cadena o línea: $

El $ ancla especifica que el patrón anterior debe producirse al final de la cadena de entrada o antes del \n final de la cadena de entrada.

Si usa $ con la opción RegexOptions.Multiline, la coincidencia también puede producirse al final de una línea. Tenga en cuenta que $ está satisfecho en \n pero no en \r\n (la combinación de caracteres de retorno de carro y nueva línea, o CR/LF). Para controlar la combinación de caracteres CR/LF, incluya \r?$ en el patrón de expresión regular. Tenga en cuenta que \r?$ incluirá cualquier \r en la comparación.

A partir de .NET 11, puede usar RegexOptions.AnyNewLine para que $ reconozca todas las secuencias de nueva línea comunes en lugar de solo \n. A diferencia de la \r?$ solución alternativa, AnyNewLine trata \r\n como una secuencia atómica, por lo que \r no se incluye en la correspondencia. Para obtener más información, consulte El modo AnyNewLine.

El siguiente ejemplo agrega el $ ancla al patrón de expresión regular utilizado en el ejemplo de la sección Inicio de cadena o línea. Cuando se usa con la cadena de entrada original, que incluye cinco líneas de texto, el Regex.Matches(String, String) método no puede encontrar una coincidencia, porque el final de la primera línea no coincide con el $ patrón. Cuando la cadena de entrada original se divide en una matriz de cadenas, el Regex.Matches(String, String) método realiza correctamente la coincidencia de cada una de las cinco líneas. Cuando se llama al Regex.Matches(String, String, RegexOptions) método con el options parámetro establecido en RegexOptions.Multiline, no se encuentra ninguna coincidencia porque el patrón de expresión regular no tiene en cuenta el carácter de retorno de carro \r. Sin embargo, cuando se modifica el patrón de expresión regular reemplazando $ por \r?$, llamando al método Regex.Matches(String, String, RegexOptions) con el parámetro options establecido en RegexOptions.Multiline se encuentran de nuevo cinco coincidencias.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string cr = Environment.NewLine;
        string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + cr +
                       "Chicago Cubs, National League, 1903-present" + cr +
                       "Detroit Tigers, American League, 1901-present" + cr +
                       "New York Giants, National League, 1885-1957" + cr +
                       "Washington Senators, American League, 1901-1960" + cr;
        Match match;

        string basePattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";
        string pattern = basePattern + "$";
        Console.WriteLine("Attempting to match the entire input string:");
        match = Regex.Match(input, pattern);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        string[] teams = input.Split(new String[] { cr }, StringSplitOptions.RemoveEmptyEntries);
        Console.WriteLine("Attempting to match each element in a string array:");
        foreach (string team in teams)
        {
            match = Regex.Match(team, pattern);
            if (match.Success)
            {
                Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
                foreach (Capture capture in match.Groups[5].Captures)
                    Console.Write(capture.Value);
                Console.WriteLine(".");
            }
        }
        Console.WriteLine();

        Console.WriteLine("Attempting to match each line of an input string with '$':");
        match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();

        pattern = basePattern + "\r?$";
        Console.WriteLine(@"Attempting to match each line of an input string with '\r?$':");
        match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    Attempting to match the entire input string:
//
//    Attempting to match each element in a string array:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.
//
//    Attempting to match each line of an input string with '$':
//
//    Attempting to match each line of an input string with '\r?$':
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
//    The Chicago Cubs played in the National League in 1903-present.
//    The Detroit Tigers played in the American League in 1901-present.
//    The New York Giants played in the National League in 1885-1957.
//    The Washington Senators played in the American League in 1901-1960.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
                              "Chicago Cubs, National League, 1903-present" + vbCrLf +
                              "Detroit Tigers, American League, 1901-present" + vbCrLf +
                              "New York Giants, National League, 1885-1957" + vbCrLf +
                              "Washington Senators, American League, 1901-1960" + vbCrLf

        Dim basePattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"
        Dim match As Match

        Dim pattern As String = basePattern + "$"
        Console.WriteLine("Attempting to match the entire input string:")
        match = Regex.Match(input, pattern)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        Dim teams() As String = input.Split(New String() {vbCrLf}, StringSplitOptions.RemoveEmptyEntries)
        Console.WriteLine("Attempting to match each element in a string array:")
        For Each team As String In teams
            match = Regex.Match(team, pattern)
            If match.Success Then
                Console.Write("The {0} played in the {1} in",
                               match.Groups(1).Value, match.Groups(4).Value)
                For Each capture As Capture In match.Groups(5).Captures
                    Console.Write(capture.Value)
                Next
                Console.WriteLine(".")
            End If
        Next
        Console.WriteLine()

        Console.WriteLine("Attempting to match each line of an input string with '$':")
        match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()

        pattern = basePattern + "\r?$"
        Console.WriteLine("Attempting to match each line of an input string with '\r?$':")
        match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")

            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    Attempting to match the entire input string:
'    
'    Attempting to match each element in a string array:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.
'    
'    Attempting to match each line of an input string with '$':
'    
'    Attempting to match each line of an input string with '\r?$':
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.
'    The Chicago Cubs played in the National League in 1903-present.
'    The Detroit Tigers played in the American League in 1901-present.
'    The New York Giants played in the National League in 1885-1957.
'    The Washington Senators played in the American League in 1901-1960.

Inicio solo de cadena: \A

El \A ancla especifica que debe producirse una coincidencia al principio de la cadena de entrada. Es idéntico al ^ delimitador, salvo que \A omite la RegexOptions.Multiline opción. Por lo tanto, solo puede coincidir con el inicio de la primera línea en una cadena de entrada de varias líneas.

El ejemplo siguiente es similar a los ejemplos de los delimitadores ^ y $ . Utiliza el \A delimitador en una expresión regular que extrae información sobre los años durante los que existían algunos equipos de béisbol profesionales. La cadena de entrada incluye cinco líneas. La llamada al Regex.Matches(String, String, RegexOptions) método busca solo la primera subcadena de la cadena de entrada que coincide con el patrón de expresión regular. Como se muestra en el ejemplo, la Multiline opción no tiene ningún efecto.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957\n" +
                       "Chicago Cubs, National League, 1903-present\n" +
                       "Detroit Tigers, American League, 1901-present\n" +
                       "New York Giants, National League, 1885-1957\n" +
                       "Washington Senators, American League, 1901-1960\n";

        string pattern = @"\A((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+";

        Match match = Regex.Match(input, pattern, RegexOptions.Multiline);
        while (match.Success)
        {
            Console.Write("The {0} played in the {1} in",
                              match.Groups[1].Value, match.Groups[4].Value);
            foreach (Capture capture in match.Groups[5].Captures)
                Console.Write(capture.Value);

            Console.WriteLine(".");
            match = match.NextMatch();
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957" + vbCrLf +
                            "Chicago Cubs, National League, 1903-present" + vbCrLf +
                            "Detroit Tigers, American League, 1901-present" + vbCrLf +
                            "New York Giants, National League, 1885-1957" + vbCrLf +
                            "Washington Senators, American League, 1901-1960" + vbCrLf

        Dim pattern As String = "\A((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+"

        Dim match As Match = Regex.Match(input, pattern, RegexOptions.Multiline)
        Do While match.Success
            Console.Write("The {0} played in the {1} in",
                              match.Groups(1).Value, match.Groups(4).Value)
            For Each capture As Capture In match.Groups(5).Captures
                Console.Write(capture.Value)
            Next
            Console.WriteLine(".")
            match = match.NextMatch()
        Loop
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    The Brooklyn Dodgers played in the National League in 1911, 1912, 1932-1957.

Fin de cadena o antes de finalizar nueva línea: \Z

El \Z ancla especifica que debe producirse una coincidencia al final de la cadena de entrada, o antes de \n al final de la cadena de entrada. Es idéntico al $ delimitador, salvo que \Z omite la RegexOptions.Multiline opción. Por lo tanto, en una cadena de varias líneas, solo se puede satisfacer al final de la última línea, o en la última línea antes de \n.

Tenga en cuenta que \Z se satisface en \n pero no se satisface en \r\n (la combinación de caracteres CR/LF). Para tratar CR/LF como si fuera \n, incluya \r?\Z en el patrón de expresión regular. Tenga en cuenta que esto hará que la parte \r forme parte de la coincidencia.

A partir de .NET 11, puede usar RegexOptions.AnyNewLine para que \Z reconozca todas las secuencias de nueva línea comunes en lugar de solo \n. A diferencia de la \r?\Z solución alternativa, AnyNewLine trata \r\n como una secuencia atómica, por lo que \r no se incluye en la correspondencia. Para obtener más información, consulte El modo AnyNewLine.

En el ejemplo siguiente se usa el \Z delimitador en una expresión regular similar al ejemplo de la sección Inicio de cadena o línea , que extrae información sobre los años durante los que existían algunos equipos de béisbol profesionales. La subexpresión \r?\Z de la expresión ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z regular se cumple al final de una cadena y también al final de una cadena que termina con \n o \r\n. Como resultado, cada elemento de la matriz coincide con el patrón de expresión regular.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                          "Chicago Cubs, National League, 1903-present" + Environment.NewLine,
                          "Detroit Tigers, American League, 1901-present" + Regex.Unescape(@"\n"),
                          "New York Giants, National League, 1885-1957",
                          "Washington Senators, American League, 1901-1960" + Environment.NewLine};
        string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z";

        foreach (string input in inputs)
        {
            Console.WriteLine(Regex.Escape(input));
            Match match = Regex.Match(input, pattern);
            if (match.Success)
                Console.WriteLine("   Match succeeded.");
            else
                Console.WriteLine("   Match failed.");
        }
    }
}
// The example displays the following output:
//    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
//       Match succeeded.
//    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
//       Match succeeded.
//    Detroit\ Tigers,\ American\ League,\ 1901-present\n
//       Match succeeded.
//    New\ York\ Giants,\ National\ League,\ 1885-1957
//       Match succeeded.
//    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
//       Match succeeded.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                              "Chicago Cubs, National League, 1903-present" + vbCrLf,
                              "Detroit Tigers, American League, 1901-present" + vbLf,
                              "New York Giants, National League, 1885-1957",
                              "Washington Senators, American League, 1901-1960" + vbCrLf}
        Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z"

        For Each input As String In inputs
            Console.WriteLine(Regex.Escape(input))
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine("   Match succeeded.")
            Else
                Console.WriteLine("   Match failed.")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
'       Match succeeded.
'    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
'       Match succeeded.
'    Detroit\ Tigers,\ American\ League,\ 1901-present\n
'       Match succeeded.
'    New\ York\ Giants,\ National\ League,\ 1885-1957
'       Match succeeded.
'    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
'       Match succeeded.

Fin de solo cadena de caracteres: \z

El \z ancla especifica que debe producirse una coincidencia al final de la cadena de entrada. Al igual que el elemento de lenguaje $, \z omite la opción RegexOptions.Multiline. A diferencia del elemento de lenguaje \Z, \z no se satisface por un carácter \n al final de una cadena. Por lo tanto, solo puede coincidir con el final de la cadena de entrada.

En el ejemplo siguiente se usa el \z ancla en una expresión regular que por lo demás es idéntico al ejemplo de la sección anterior, que extrae información sobre los años durante los que existieron algunos equipos profesionales de béisbol. En el ejemplo se intenta hacer coincidir cada uno de cinco elementos de una matriz de cadenas con el patrón ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\zde expresión regular . Dos de las cadenas terminan con caracteres de retorno de carro y de avance de línea, uno termina con un carácter de avance de línea, y dos terminan sin un carácter de retorno de carro ni de avance de línea. Como se muestra en la salida, solo las cadenas que no contengan un carácter de retorno de carro ni de avance de línea coinciden con el patrón.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string[] inputs = { "Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                          "Chicago Cubs, National League, 1903-present" + Environment.NewLine,
                          "Detroit Tigers, American League, 1901-present\n",
                          "New York Giants, National League, 1885-1957",
                          "Washington Senators, American League, 1901-1960" + Environment.NewLine };
        string pattern = @"^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z";

        foreach (string input in inputs)
        {
            Console.WriteLine(Regex.Escape(input));
            Match match = Regex.Match(input, pattern);
            if (match.Success)
                Console.WriteLine("   Match succeeded.");
            else
                Console.WriteLine("   Match failed.");
        }
    }
}
// The example displays the following output:
//    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
//       Match succeeded.
//    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
//       Match failed.
//    Detroit\ Tigers,\ American\ League,\ 1901-present\n
//       Match failed.
//    New\ York\ Giants,\ National\ League,\ 1885-1957
//       Match succeeded.
//    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
//       Match failed.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"Brooklyn Dodgers, National League, 1911, 1912, 1932-1957",
                              "Chicago Cubs, National League, 1903-present" + vbCrLf,
                              "Detroit Tigers, American League, 1901-present" + vbLf,
                              "New York Giants, National League, 1885-1957",
                              "Washington Senators, American League, 1901-1960" + vbCrLf}
        Dim pattern As String = "^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z"

        For Each input As String In inputs
            Console.WriteLine(Regex.Escape(input))
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then
                Console.WriteLine("   Match succeeded.")
            Else
                Console.WriteLine("   Match failed.")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Brooklyn\ Dodgers,\ National\ League,\ 1911,\ 1912,\ 1932-1957
'       Match succeeded.
'    Chicago\ Cubs,\ National\ League,\ 1903-present\r\n
'       Match failed.
'    Detroit\ Tigers,\ American\ League,\ 1901-present\n
'       Match failed.
'    New\ York\ Giants,\ National\ League,\ 1885-1957
'       Match succeeded.
'    Washington\ Senators,\ American\ League,\ 1901-1960\r\n
'       Match failed.

Coincidencias contiguas: \G

El \G delimitador especifica que debe producirse una coincidencia en el punto en el que finalizó la coincidencia anterior, o si no había ninguna coincidencia anterior, en la posición de la cadena donde se inició la coincidencia. Cuando se usa este delimitador con el Regex.Matches método o Match.NextMatch , se garantiza que todas las coincidencias sean contiguas.

Sugerencia

Normalmente, coloca un \G ancla en el extremo izquierdo del patrón. En el caso poco común de realizar una búsqueda de derecha a izquierda, coloque el \G ancla en el extremo derecho del patrón.

En el ejemplo siguiente se usa una expresión regular para extraer los nombres de especies de ratones de una cadena delimitada por comas.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "capybara,squirrel,chipmunk,porcupine,gopher," +
                       "beaver,groundhog,hamster,guinea pig,gerbil," +
                       "chinchilla,prairie dog,mouse,rat";
        string pattern = @"\G(\w+\s?\w*),?";
        Match match = Regex.Match(input, pattern);
        while (match.Success)
        {
            Console.WriteLine(match.Groups[1].Value);
            match = match.NextMatch();
        }
    }
}
// The example displays the following output:
//       capybara
//       squirrel
//       chipmunk
//       porcupine
//       gopher
//       beaver
//       groundhog
//       hamster
//       guinea pig
//       gerbil
//       chinchilla
//       prairie dog
//       mouse
//       rat

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "capybara,squirrel,chipmunk,porcupine,gopher," +
                              "beaver,groundhog,hamster,guinea pig,gerbil," +
                              "chinchilla,prairie dog,mouse,rat"
        Dim pattern As String = "\G(\w+\s?\w*),?"
        Dim match As Match = Regex.Match(input, pattern)
        Do While match.Success
            Console.WriteLine(match.Groups(1).Value)
            match = match.NextMatch()
        Loop
    End Sub
End Module
' The example displays the following output:
'       capybara
'       squirrel
'       chipmunk
'       porcupine
'       gopher
'       beaver
'       groundhog
'       hamster
'       guinea pig
'       gerbil
'       chinchilla
'       prairie dog
'       mouse
'       rat

La expresión regular \G(\w+\s?\w*),? se interpreta como se muestra en la tabla siguiente.

Modelo Descripción
\G Comienza donde finalizó el último encuentro.
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.
\s? Coincide con cero o un espacio.
\w* Buscar una coincidencia con cero o más caracteres de palabras.
(\w+\s?\w*) Coincide con uno o varios caracteres de palabra seguidos de cero o un espacio, seguido de cero o más caracteres de palabra. Este es el primer grupo de captura.
,? Coincidir con cero o una ocurrencia de un carácter de coma literal.

límite de palabra: \b

El \b ancla especifica que la coincidencia debe producirse en un límite entre un carácter de palabra (el elemento de lenguaje \w) y un carácter que no sea de palabra (el elemento de lenguaje \W). Los caracteres de palabra constan de caracteres alfanuméricos y guiones bajos; un carácter no de palabra es cualquier carácter que no sea ni alfanumérico ni un guión bajo. (Para obtener más información, vea Clases de caracteres). La coincidencia también puede producirse en un límite de palabras al principio o al final de la cadena.

El \b delimitador se usa con frecuencia para asegurarse de que una subexpresión coincide con una palabra completa en lugar de simplemente el principio o el final de una palabra. La expresión \bare\w*\b regular del ejemplo siguiente ilustra este uso. Coincide con cualquier palabra que comience con la subcadena "are". La salida del ejemplo también muestra que \b coincide con el principio y el final de la cadena de entrada.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "area bare arena mare";
        string pattern = @"\bare\w*\b";
        Console.WriteLine("Words that begin with 'are':");
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine($"'{match.Value}' found at position {match.Index}");
    }
}
// The example displays the following output:
//       Words that begin with 'are':
//       'area' found at position 0
//       'arena' found at position 10

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "area bare arena mare"
        Dim pattern As String = "\bare\w*\b"
        Console.WriteLine("Words that begin with 'are':")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("'{0}' found at position {1}",
                              match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Words that begin with 'are':
'       'area' found at position 0
'       'arena' found at position 10

El patrón de la expresión regular se interpreta como se muestra en la tabla siguiente.

Modelo Descripción
\b Iniciar la búsqueda de coincidencias en un límite de palabras.
are Coincide con la subcadena "are".
\w* Buscar una coincidencia con cero o más caracteres de palabras.
\b Finalizar la búsqueda de coincidencias en un límite de palabras.

Límite no Word: \B

El \B delimitador especifica que la coincidencia no debe producirse en un límite de palabras. Es lo contrario del \b ancla.

En el ejemplo siguiente se usa el \B delimitador para buscar repeticiones de la subcadena "qu" en una palabra. El patrón \Bqu\w+ de expresión regular coincide con una subcadena que comienza con un "qu" que no inicia una palabra y que continúa hasta el final de la palabra.

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "equity queen equip acquaint quiet";
        string pattern = @"\Bqu\w+";
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine($"'{match.Value}' found at position {match.Index}");
    }
}
// The example displays the following output:
//       'quity' found at position 1
//       'quip' found at position 14
//       'quaint' found at position 21

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim input As String = "equity queen equip acquaint quiet"
        Dim pattern As String = "\Bqu\w+"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("'{0}' found at position {1}",
                              match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       'quity' found at position 1
'       'quip' found at position 14
'       'quaint' found at position 21

El patrón de la expresión regular se interpreta como se muestra en la tabla siguiente.

Modelo Descripción
\B No empiece la coincidencia en un límite de palabras.
qu Coincide con la subcadena "qu".
\w+ Buscar coincidencias con uno o más caracteres alfabéticos.

Consulte también

  • Last updated on