Âncoras em expressões regulares

Âncoras, ou asserções atômicas de largura zero, especificam uma posição na cadeia de caracteres onde uma correspondência deve ocorrer. Quando você usa uma âncora em sua expressão de pesquisa, o mecanismo de expressão regular não avança pela cadeia de caracteres nem consome caracteres; ele procura uma correspondência apenas na posição especificada. Por exemplo, ^ especifica que a correspondência deve começar no início de uma linha ou cadeia de caracteres. Portanto, a expressão ^http: regular corresponde a "http:" somente quando ocorre no início de uma linha. A tabela a seguir lista as âncoras suportadas pelas expressões regulares no .NET.

Âncora	Description
^	Por padrão, a correspondência deve ocorrer no início da cadeia de caracteres; No modo multilinha, deve ocorrer no início da linha. Para obter mais informações, consulte Início da cadeia de caracteres ou linha.
$	Por padrão, a correspondência deve ocorrer no final da cadeia de caracteres ou antes \n no final da cadeia de caracteres, no modo multilinha, deve ocorrer no final da linha ou antes \n no final da linha. Para obter mais informações, consulte Fim da cadeia de caracteres ou linha.
\A	A correspondência deve ocorrer apenas no início da cadeia de caracteres (sem suporte a várias linhas). Para obter mais informações, consulte Início somente de cadeia de caracteres.
\Z	A correspondência deve ocorrer no final da cadeia de caracteres ou antes \n no final da cadeia de caracteres. Para obter mais informações, consulte End of String ou Before Ending Newline.
\z	A correspondência deve ocorrer apenas no final da cadeia de caracteres. Para obter mais informações, consulte End of String Only.
\G	A partida deve começar na posição onde a partida anterior terminou, ou, se não houve correspondência anterior, na posição na cadeia de caracteres onde a correspondência começou. Para obter mais informações, consulte Correspondências contíguas.
\b	A correspondência deve ocorrer em um limite de palavras. Para obter mais informações, consulte Limite do Word.
\B	A correspondência não deve ocorrer em um limite de palavras. Para obter mais informações, consulte Limite que não é do Word.

Início da String ou Line: ^

Por padrão, a âncora ^ especifica que o padrão a seguir deve começar na posição do primeiro caractere da cadeia de caracteres. Se você usar ^ com a RegexOptions.Multiline opção (consulte Opções de expressão regular), a correspondência deve ocorrer no início de cada linha.

O exemplo a seguir usa a âncora ^ em uma expressão regular que extrai informações sobre os anos durante os quais algumas equipes profissionais de beisebol existiram. O exemplo chama duas sobrecargas do Regex.Matches método:

• A chamada para a Matches(String, String) sobrecarga localiza apenas a primeira substring na cadeia de caracteres de entrada que corresponde ao padrão de expressão regular.

• A chamada para a Matches(String, String, RegexOptions) sobrecarga com o options parâmetro definido para RegexOptions.Multiline localizar todas as cinco substrings.

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.

O padrão ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ de expressão regular é definido conforme mostrado na tabela a seguir.

Padrão	Description
^	Comece a correspondência no início da cadeia de caracteres de entrada (ou no início da linha se o método for chamado com a RegexOptions.Multiline opção).
((\w+(\s?)){2,}	Corresponder a um ou mais caracteres de palavras seguidos de zero ou de um espaço pelo menos duas vezes. Este é o primeiro grupo de captura. Esta expressão também define um segundo e terceiro grupo de captura: O segundo consiste na palavra capturada, e o terceiro consiste no espaço em branco capturado.
,\s	Corresponder a uma vírgula seguida de um caractere de espaço em branco.
(\w+\s\w+)	Corresponder um ou mais caracteres de palavra seguidos por um espaço, seguido por um ou mais caracteres de palavra. Este é o quarto grupo de captura.
,	Corresponda a uma vírgula.
\s\d{4}	Corresponder a um espaço seguido de quatro dígitos decimais.
(-(\d{4}|present))?	Corresponder a zero ou a uma ocorrência de um hífen seguido de quatro dígitos decimais ou da cadeia de caracteres "presente". Este é o sexto grupo de captura. Também inclui um sétimo grupo de captura.
,?	Corresponder a zero ou a uma ocorrência de vírgula.
(\s\d{4}(-(\d{4}|present))?,?)+	Corresponder a uma ou mais ocorrências do seguinte: um espaço, quatro dígitos decimais, zero ou uma ocorrência de um hífen seguido por quatro dígitos decimais ou a cadeia de caracteres "presente" e zero ou uma vírgula. Este é o quinto grupo de captura.

Fim da corda ou linha: $

A $ âncora especifica que o padrão anterior deve ocorrer no final da cadeia de caracteres de entrada ou antes \n no final da cadeia de caracteres de entrada.

Se você usar $ com a RegexOptions.Multiline opção, a correspondência também pode ocorrer no final de uma linha. Observe que $ está satisfeito em \n , mas não em \r\n (a combinação de retorno de carro e caracteres de nova linha, ou CR/LF). Para manipular a combinação de caracteres CR/LF, inclua \r?$ no padrão de expressão regular. Note que \r?$ incluirá qualquer \r um na partida.

O exemplo a seguir adiciona a âncora $ ao padrão de expressão regular usado no exemplo na seção Start of String ou Line . Quando usado com a cadeia de caracteres de entrada original, que inclui cinco linhas de texto, o Regex.Matches(String, String) método não consegue encontrar uma correspondência, porque o final da primeira linha não corresponde ao $ padrão. Quando a cadeia de caracteres de entrada original é dividida em uma matriz de cadeia de caracteres, o Regex.Matches(String, String) método consegue corresponder a cada uma das cinco linhas. Quando o Regex.Matches(String, String, RegexOptions) método é chamado com o options parâmetro definido como RegexOptions.Multiline, nenhuma correspondência é encontrada porque o padrão de expressão regular não leva em conta o caractere \rde retorno de carro. No entanto, quando o padrão de expressão regular é modificado substituindo $ por \r?$, chamando o Regex.Matches(String, String, RegexOptions) método com o options parâmetro definido para RegexOptions.Multiline novamente encontra cinco correspondências.

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.

Início apenas da cadeia de caracteres: \a

A \A âncora especifica que uma correspondência deve ocorrer no início da cadeia de caracteres de entrada. É idêntico à âncora ^ , exceto que \A ignora a RegexOptions.Multiline opção. Portanto, ele só pode corresponder ao início da primeira linha em uma cadeia de entrada de várias linhas.

O exemplo a seguir é semelhante aos exemplos para as âncoras ^ e $ . Ele usa a âncora \A em uma expressão regular que extrai informações sobre os anos durante os quais algumas equipes profissionais de beisebol existiram. A cadeia de caracteres de entrada inclui cinco linhas. A chamada para o Regex.Matches(String, String, RegexOptions) método localiza apenas a primeira substring na cadeia de caracteres de entrada que corresponde ao padrão de expressão regular. Como mostra o exemplo, a Multiline opção não tem efeito.

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.

Fim da cadeia de caracteres ou antes de terminar a nova linha: \z

A \Z âncora especifica que uma correspondência deve ocorrer no final da cadeia de caracteres de entrada ou antes \n no final da cadeia de caracteres de entrada. É idêntico à âncora $ , exceto que \Z ignora a RegexOptions.Multiline opção. Portanto, em uma cadeia de caracteres de várias linhas, ela só pode ser satisfeita pelo final da última linha ou pela última linha antes \nde .

Observe que \Z está satisfeito em \n , mas não está satisfeito em \r\n (a combinação de caracteres CR/LF). Para tratar CR/LF como se fosse \n, inclua \r?\Z no padrão de expressão regular. Note que isso fará a \r parte da partida.

O exemplo a seguir usa a âncora \Z em uma expressão regular semelhante ao exemplo na seção Start of String ou Line , que extrai informações sobre os anos durante os quais algumas equipes profissionais de beisebol existiram. A subexpressão \r?\Z na expressão ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z regular é satisfeita no final de uma cadeia de caracteres e também no final de uma cadeia de caracteres que termina com \n ou \r\n. Como resultado, cada elemento na matriz corresponde ao padrão de expressão 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.

Somente fim da cadeia de caracteres: \z

A \z âncora especifica que uma correspondência deve ocorrer no final da cadeia de caracteres de entrada. Como o $ elemento language, \z ignora a RegexOptions.Multiline opção. Ao contrário do \Z elemento language, \z não é satisfeito por um \n caractere no final de uma cadeia de caracteres. Portanto, ele só pode corresponder ao final da cadeia de caracteres de entrada.

O exemplo a seguir usa a âncora \z em uma expressão regular que é idêntica ao exemplo da seção anterior, que extrai informações sobre os anos durante os quais algumas equipes profissionais de beisebol existiram. O exemplo tenta corresponder cada um dos cinco elementos em uma matriz de cadeia de caracteres com o padrão ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\zde expressão regular . Duas das cadeias de caracteres terminam com caracteres de retorno de carro e alimentação de linha, uma termina com um caractere de alimentação de linha e duas terminam sem um retorno de carro nem um caractere de alimentação de linha. Como mostra a saída, apenas as cadeias de caracteres sem um retorno de carro ou caractere de alimentação de linha correspondem ao padrão.

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.

Correspondências contíguas: \g

A \G âncora especifica que uma correspondência deve ocorrer no ponto em que a correspondência anterior terminou, ou, se não houve correspondência anterior, na posição na cadeia de caracteres onde a correspondência começou. Quando você usa essa âncora com o Regex.Matches método or Match.NextMatch , ela garante que todas as correspondências sejam contíguas.

Gorjeta

Normalmente, você coloca uma \G âncora na extremidade esquerda do padrão. No caso incomum de você estar realizando uma pesquisa da direita para a esquerda, coloque a âncora \G na extremidade direita do seu padrão.

O exemplo a seguir usa uma expressão regular para extrair os nomes de espécies de roedores de uma cadeia delimitada por vírgula.

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

A expressão \G(\w+\s?\w*),? regular é interpretada como mostrado na tabela a seguir.

Padrão	Description
\G	Comece onde a última partida terminou.
\w+	Corresponder a um ou mais caracteres de palavra.
\s?	Corresponder a zero ou a um espaço.
\w*	Corresponder a zero ou mais caracteres de palavras.
(\w+\s?\w*)	Corresponder um ou mais caracteres de palavra seguidos por zero ou um espaço, seguido por zero ou mais caracteres de palavra. Este é o primeiro grupo de captura.
,?	Corresponder a zero ou uma ocorrência de um caractere de vírgula literal.

Limite da palavra: \b

A \b âncora especifica que a correspondência deve ocorrer em um limite entre um caractere de palavra (o \w elemento de idioma) e um caractere de não-palavra (o \W elemento de idioma). Os caracteres de palavra consistem em caracteres alfanuméricos e sublinhados; Um caractere não-palavra é qualquer caractere que não seja alfanumérico ou um sublinhado. (Para obter mais informações, consulte Classes de Personagens.) A correspondência também pode ocorrer em um limite de palavra no início ou no final da cadeia de caracteres.

A \b âncora é frequentemente usada para garantir que uma subexpressão corresponda a uma palavra inteira em vez de apenas ao início ou fim de uma palavra. A expressão \bare\w*\b regular no exemplo a seguir ilustra esse uso. Ele corresponde a qualquer palavra que começa com a substring "are". A saída do exemplo também ilustra que \b corresponde ao início e ao fim da cadeia de caracteres 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("'{0}' found at position {1}",
                              match.Value, 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

O padrão de expressão regular é interpretado como mostrado na tabela a seguir.

Padrão	Description
\b	Comece a partida com um limite de palavras.
are	Corresponda à substring "are".
\w*	Corresponder a zero ou mais caracteres de palavras.
\b	Termine a partida com um limite de palavras.

Limite não Word: \B

A \B âncora especifica que a correspondência não deve ocorrer em um limite de palavras. É o oposto da âncora \b .

O exemplo a seguir usa a âncora \B para localizar ocorrências da substring "qu" em uma palavra. O padrão \Bqu\w+ de expressão regular corresponde a uma substring que começa com um "qu" que não inicia uma palavra e que continua até o final da palavra.

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("'{0}' found at position {1}",
                              match.Value, 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

O padrão de expressão regular é interpretado como mostrado na tabela a seguir.

Padrão	Description
\B	Não comece a partida com um limite de palavras.
qu	Corresponda à substring "qu".
\w+	Corresponder a um ou mais caracteres de palavra.

Consulte também

• Linguagem de Expressão Regular - Referência Rápida
• Opções de expressão regular