Âncoras em expressões regularesAnchors in Regular Expressions

Âncoras ou asserções atômicas de largura zero, especificam uma posição na cadeia de caracteres em que uma correspondência deve ocorrer.Anchors, or atomic zero-width assertions, specify a position in the string where a match must occur. Quando você usa uma âncora na sua expressão de pesquisa, o mecanismo de expressões regulares não avança pela cadeia de caracteres ou consome caracteres, ele procura uma correspondência apenas na posição especificada.When you use an anchor in your search expression, the regular expression engine does not advance through the string or consume characters; it looks for a match in the specified position only. Por exemplo, ^ Especifica que a correspondência deve começar no início de uma linha ou cadeia de caracteres.For example, ^ specifies that the match must start at the beginning of a line or string. Portanto, a expressão regular ^http: corresponde a "http:" apenas quando ele ocorre no início de uma linha.Therefore, the regular expression ^http: matches "http:" only when it occurs at the beginning of a line. A tabela a seguir lista as âncoras com suporte pelas expressões regulares no .NET.The following table lists the anchors supported by the regular expressions in .NET.

ÂncoraAnchor DESCRIÇÃODescription
^ 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.By default, the match must occur at the beginning of the string; in multiline mode, it must occur at the beginning of the line. Para saber mais, veja Início da cadeia de caracteres ou linha.For more information, see Start of String or Line.
$ Por padrão, a correspondência deve ocorrer no fim da cadeia de caracteres ou antes de \n no fim da cadeia de caracteres. No modo multilinha, deve ocorrer no fim da linha ou antes de \n no fim da linha.By default, the match must occur at the end of the string or before \n at the end of the string; in multiline mode, it must occur at the end of the line or before \n at the end of the line. Para saber mais, veja Fim da cadeia de caracteres ou linha.For more information, see End of String or Line.
\A A correspondência deve ocorrer no início da cadeia de caracteres apenas (sem suporte a multilinha).The match must occur at the beginning of the string only (no multiline support). Para saber mais, veja Início da cadeia de caracteres apenas.For more information, see Start of String Only.
\Z A correspondência deve ocorrer no final da cadeia de caracteres ou antes de \n no final da cadeia de caracteres.The match must occur at the end of the string, or before \n at the end of the string. Para saber mais, veja Final da Cadeia de Caracteres ou Antes de Terminar Nova Linha.For more information, see End of String or Before Ending Newline.
\z A correspondência deve ocorrer apenas no final da cadeia de caracteres.The match must occur at the end of the string only. Para saber mais, veja Fim da cadeia de caracteres apenas.For more information, see End of String Only.
\G A correspondência deve começar na posição em que a correspondência anterior foi encerrada.The match must start at the position where the previous match ended. Para saber mais, veja Correspondências contíguas.For more information, see Contiguous Matches.
\b A correspondência deve ocorrer em um limite de palavra.The match must occur on a word boundary. Para saber mais, veja Limite de palavra.For more information, see Word Boundary.
\B A correspondência não deve ocorrer em um limite de palavra.The match must not occur on a word boundary. Para saber mais, veja Limite não pertencente a palavras.For more information, see Non-Word Boundary.

Início da Cadeia de Caracteres ou Linha: ^Start of String or Line: ^

Por padrão, a âncora ^ especifica que o seguinte padrão deve começar na posição do primeiro caractere da cadeia de caracteres.By default, the ^ anchor specifies that the following pattern must begin at the first character position of the string. Se você usar ^ com a opção RegexOptions.Multiline (veja Opções de expressões regulares), a correspondência deverá ocorrer no início de cada linha.If you use ^ with the RegexOptions.Multiline option (see Regular Expression Options), the match must occur at the beginning of each line.

O exemplo a seguir usa a âncora ^ em uma expressão regular que extrai informações sobre os anos durante os quais algumas equipes de profissionais de beisebol existiram.The following example uses the ^ anchor in a regular expression that extracts information about the years during which some professional baseball teams existed. O exemplo chama duas sobrecargas do método Regex.Matches:The example calls two overloads of the Regex.Matches method:

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 de expressão regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ é definido conforme mostrado na tabela a seguir.The regular expression pattern ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+ is defined as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
^ Começa a correspondência no início da cadeia de caracteres de entrada (ou o início da linha se o método for chamado com a opção RegexOptions.Multiline).Begin the match at the beginning of the input string (or the beginning of the line if the method is called with the RegexOptions.Multiline option).
((\w+(\s?)){2,} Corresponde a um ou mais caracteres de palavra seguidos por zero ou um espaço, pelo menos, duas vezes.Match one or more word characters followed either by zero or by one space at least two times. Este é o primeiro grupo de captura.This is the first capturing group. Esta expressão também define um segundo e um terceiro grupo de captura: O segundo consiste na palavra capturada e o terceiro consiste no espaço em branco capturado.This expression also defines a second and third capturing group: The second consists of the captured word, and the third consists of the captured white space.
,\s Corresponde a uma vírgula seguida por um caractere de espaço em branco.Match a comma followed by a white-space character.
(\w+\s\w+) Corresponde a um ou mais caracteres de palavra seguidos por um espaço, seguido por um ou mais caracteres de palavra.Match one or more word characters followed by a space, followed by one or more word characters. Este é o quarto grupo de captura.This is the fourth capturing group.
, Corresponde a uma vírgula.Match a comma.
\s\d{4} Corresponde a um espaço seguido por quatro dígitos decimais.Match a space followed by four decimal digits.
(-(\d{4}|present))? Corresponde a zero ou uma ocorrência de um hífen seguido por quatro dígitos decimais ou a cadeia de caracteres "present".Match zero or one occurrence of a hyphen followed by four decimal digits or the string "present". Este é o sexto grupo de captura.This is the sixth capturing group. Ele também inclui um sétimo grupo de captura.It also includes a seventh capturing group.
,? Corresponde a zero ou uma ocorrência de uma vírgula.Match zero or one occurrence of a comma.
(\s\d{4}(-(\d{4}|present))?,?)+ Corresponde 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 "present" e zero ou uma vírgula.Match one or more occurrences of the following: a space, four decimal digits, zero or one occurrence of a hyphen followed by four decimal digits or the string "present", and zero or one comma. Este é o quinto grupo de captura.This is the fifth capturing group.

Voltar ao inícioBack to top

Final da Cadeia de Caracteres ou da Linha: $End of String or Line: $

A âncora $ especifica que o padrão anterior deve ocorrer no final da cadeia de caracteres de entrada ou antes de \n no final da cadeia de caracteres de entrada.The $ anchor specifies that the preceding pattern must occur at the end of the input string, or before \n at the end of the input string.

Se você usar $ com a opção RegexOptions.Multiline, a correspondência também pode ocorrer no final de uma linha.If you use $ with the RegexOptions.Multiline option, the match can also occur at the end of a line. Observe que $ corresponde a \n, mas não corresponde a \r\n (a combinação de caracteres de nova linha e de retorno de carro ou CR/LF).Note that $ matches \n but does not match \r\n (the combination of carriage return and newline characters, or CR/LF). De acordo com a combinação de caracteres CR/LF, inclua \r?$ no padrão de expressão regular.To match the CR/LF character combination, include \r?$ in the regular expression pattern.

O exemplo a seguir adiciona a âncora $ ao padrão de expressão regular usada no exemplo na seção Início da cadeia de caracteres ou linha.The following example adds the $ anchor to the regular expression pattern used in the example in the Start of String or Line section. Quando usado com a cadeia de caracteres de entrada original, que inclui cinco linhas de texto, o método Regex.Matches(String, String) não pode localizar uma correspondência, pois o final da primeira linha não corresponde ao padrão $.When used with the original input string, which includes five lines of text, the Regex.Matches(String, String) method is unable to find a match, because the end of the first line does not match the $ pattern. Quando a cadeia de caracteres de entrada original é dividida em uma matriz de cadeia de caracteres, o método Regex.Matches(String, String) obtém sucesso na correspondência de cada uma das cinco linhas.When the original input string is split into a string array, the Regex.Matches(String, String) method succeeds in matching each of the five lines. Quando o método Regex.Matches(String, String, RegexOptions) for chamado com o parâmetro options definido como RegexOptions.Multiline, nenhuma correspondência será encontrada porque o padrão de expressão regular não considera o elemento de retorno de carro (\u+000D).When the Regex.Matches(String, String, RegexOptions) method is called with the options parameter set to RegexOptions.Multiline, no matches are found because the regular expression pattern does not account for the carriage return element (\u+000D). No entanto, quando o padrão de expressão regular é modificado substituindo $ por \r?$, chamar o método Regex.Matches(String, String, RegexOptions) com o parâmetro options definido como RegexOptions.Multiline novamente encontra cinco correspondências.However, when the regular expression pattern is modified by replacing $ with \r?$, calling the Regex.Matches(String, String, RegexOptions) method with the options parameter set to RegexOptions.Multiline again finds five matches.

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.

Voltar ao inícioBack to top

Apenas Início da Cadeia de Caracteres: \AStart of String Only: \A

A âncora \A especifica que uma correspondência deve ocorrer no início da cadeia de caracteres de entrada.The \A anchor specifies that a match must occur at the beginning of the input string. Ela é idêntica à âncora ^, exceto que \A ignora a opção RegexOptions.Multiline.It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Portanto, ela pode corresponder apenas ao início da primeira linha em uma cadeia de caracteres de entrada multilinhas.Therefore, it can only match the start of the first line in a multiline input string.

O exemplo a seguir é semelhante aos exemplos das âncoras ^ e $.The following example is similar to the examples for the ^ and $ anchors. Ele usa a âncora \A em uma expressão regular que extrai informações sobre os anos durante os quais algumas equipes de profissionais de beisebol existiram.It uses the \A anchor in a regular expression that extracts information about the years during which some professional baseball teams existed. A cadeia de caracteres de entrada inclui cinco linhas.The input string includes five lines. A chamada para o método Regex.Matches(String, String, RegexOptions) localiza apenas a primeira subcadeia de caracteres na cadeia de caracteres de entrada que corresponde ao padrão de expressão regular.The call to the Regex.Matches(String, String, RegexOptions) method finds only the first substring in the input string that matches the regular expression pattern. Como o exemplo mostra, a opção Multiline não tem efeito.As the example shows, the Multiline option has no effect.

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.

Voltar ao inícioBack to top

Final da Cadeia de Caracteres ou Antes de Terminar Nova Linha: \ ZEnd of String or Before Ending Newline: \Z

A âncora \Z especifica que a correspondência deve ocorrer no final da cadeia de caracteres de entrada ou antes de \n no final da cadeia de caracteres de entrada.The \Z anchor specifies that a match must occur at the end of the input string, or before \n at the end of the input string. Ela é idêntica à âncora $, exceto que \Z ignora a opção RegexOptions.Multiline.It is identical to the $ anchor, except that \Z ignores the RegexOptions.Multiline option. Portanto, em uma cadeia de caracteres multilinhas, ela pode corresponder apenas ao final da última linha ou à última linha antes de \n.Therefore, in a multiline string, it can only match the end of the last line, or the last line before \n.

Observe que \Z corresponde a \n mas não corresponde a \r\n (a combinação de caracteres CR/LF).Note that \Z matches \n but does not match \r\n (the CR/LF character combination). Para corresponder a CR/LF, inclua \r?\Z no padrão da expressão regular.To match CR/LF, include \r?\Z in the regular expression pattern.

O exemplo a seguir usa a âncora \Z em uma expressão regular semelhante ao exemplo na seção Início da Cadeia de Caracteres ou Linha, que extrai informações sobre os anos durante os quais algumas equipes de profissionais de beisebol existiram.The following example uses the \Z anchor in a regular expression that is similar to the example in the Start of String or Line section, which extracts information about the years during which some professional baseball teams existed. A subexpressão \r?\Z na expressão regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z corresponde ao final de uma cadeia de caracteres e também corresponde a uma cadeia de caracteres que termina com \n ou \r\n.The subexpression \r?\Z in the regular expression ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\Z matches the end of a string, and also matches a string that ends with \n or \r\n. Como resultado, cada elemento da matriz corresponde ao padrão da expressão regular.As a result, each element in the array matches the regular expression pattern.

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.

Voltar ao inícioBack to top

Apenas Final da Cadeia de Caracteres: \ zEnd of String Only: \z

A âncora \z especifica que uma correspondência deve ocorrer no final da cadeia de caracteres de entrada.The \z anchor specifies that a match must occur at the end of the input string. Como o elemento de linguagem $, o \z ignora a opção RegexOptions.Multiline.Like the $ language element, \z ignores the RegexOptions.Multiline option. Diferentemente do elemento de linguagem \Z, \z não corresponde ao caractere \n no final de uma cadeia de caracteres.Unlike the \Z language element, \z does not match a \n character at the end of a string. Portanto, ele pode corresponder somente à última linha da cadeia de caracteres de entrada.Therefore, it can only match the last line of the input string.

O exemplo a seguir usa a âncora \z em uma expressão regular que é de outro modo idêntica ao exemplo na seção anterior, que extrai informações sobre os anos durante os quais algumas equipes de profissionais de beisebol existiram.The following example uses the \z anchor in a regular expression that is otherwise identical to the example in the previous section, which extracts information about the years during which some professional baseball teams existed. O exemplo tenta corresponder cada um dos cinco elementos em uma matriz de cadeia de caracteres com um padrão de expressão regular ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z.The example tries to match each of five elements in a string array with the regular expression pattern ^((\w+(\s?)){2,}),\s(\w+\s\w+),(\s\d{4}(-(\d{4}|present))?,?)+\r?\z. Duas das cadeias de caracteres terminam com os caracteres de alimentação de linha e retorno de carro, uma termina com um caractere de alimentação de linha e duas terminam sem um caractere de retorno de carro nem um caractere de alimentação de linha.Two of the strings end with carriage return and line feed characters, one ends with a line feed character, and two end with neither a carriage return nor a line feed character. Como a saída mostra, apenas as cadeias de caracteres sem um caractere de retorno de carro ou de alimentação de linha correspondem ao padrão.As the output shows, only the strings without a carriage return or line feed character match the pattern.

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.

Voltar ao inícioBack to top

Correspondências Contíguas: \ GContiguous Matches: \G

A âncora \G especifica que uma correspondência deve ocorrer no ponto em que a correspondência anterior foi encerrada.The \G anchor specifies that a match must occur at the point where the previous match ended. Quando você usa essa âncora com o método Regex.Matches ou Match.NextMatch, ela garante que todas as correspondências são contíguas.When you use this anchor with the Regex.Matches or Match.NextMatch method, it ensures that all matches are contiguous.

O exemplo a seguir usa uma expressão regular para extrair os nomes de espécies de roedores de uma cadeia de caracteres delimitada por vírgulas.The following example uses a regular expression to extract the names of rodent species from a comma-delimited string.

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 regular \G(\w+\s?\w*),? é interpretada conforme mostrado na tabela a seguir.The regular expression \G(\w+\s?\w*),? is interpreted as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\G Começa onde a última correspondência terminou.Begin where the last match ended.
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.
\s? Corresponde a zero ou um espaço.Match zero or one space.
\w* Corresponder a zero ou mais caracteres de palavra.Match zero or more word characters.
(\w+\s?\w*) Corresponde a um ou mais caracteres de palavra seguidos por zero ou um espaço, seguido por zero ou mais caracteres de palavra.Match one or more word characters followed by zero or one space, followed by zero or more word characters. Este é o primeiro grupo de captura.This is the first capturing group.
,? Corresponde a zero ou uma ocorrência de um caractere de vírgula literal.Match zero or one occurrence of a literal comma character.

Voltar ao inícioBack to top

Limite de Palavra: \bWord Boundary: \b

A âncora \b especifica que a correspondência deve ocorrer em um limite entre um caractere de palavra (o elemento de linguagem \w) e um caractere não pertencente a palavras (o elemento de linguagem \W).The \b anchor specifies that the match must occur on a boundary between a word character (the \w language element) and a non-word character (the \W language element). Os caracteres de palavra consistem em caracteres alfanuméricos e sublinhados. Um caractere não pertencente a palavras é qualquer caractere que não seja alfanumérico ou um sublinhado.Word characters consist of alphanumeric characters and underscores; a non-word character is any character that is not alphanumeric or an underscore. (Para saber mais, veja Classes de caracteres.) A correspondência também pode ocorrer em um limite de palavra no início ou no final da cadeia de caracteres.(For more information, see Character Classes.) The match may also occur on a word boundary at the beginning or end of the string.

A âncora \b frequentemente é usada para garantir que uma subexpressão corresponda a uma palavra inteira, em vez de apenas ao início ou final de uma palavra.The \b anchor is frequently used to ensure that a subexpression matches an entire word instead of just the beginning or end of a word. A expressão regular \bare\w*\b no exemplo a seguir ilustra esse uso.The regular expression \bare\w*\b in the following example illustrates this usage. Ela corresponde a qualquer palavra que comece com a subcadeia de caracteres "are".It matches any word that begins with the substring "are". A saída do exemplo também ilustra que \b corresponde ao início e ao final da cadeia de caracteres de entrada.The output from the example also illustrates that \b matches both the beginning and the end of the input string.

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 da expressão regular é interpretado conforme a tabela a seguir.The regular expression pattern is interpreted as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\b Começa a correspondência em um limite de palavra.Begin the match at a word boundary.
are Corresponde à subcadeia de caracteres “are”.Match the substring "are".
\w* Corresponder a zero ou mais caracteres de palavra.Match zero or more word characters.
\b Termina a correspondência em um limite de palavra.End the match at a word boundary.

Voltar ao inícioBack to top

Limite de Não Palavra: \BNon-Word Boundary: \B

A âncora \B especifica que a correspondência não deve ocorrer em um limite de palavra.The \B anchor specifies that the match must not occur on a word boundary. É o oposto da âncora \b.It is the opposite of the \b anchor.

O exemplo a seguir usa a âncora \B para localizar ocorrências da subcadeia de caracteres "qu" em uma palavra.The following example uses the \B anchor to locate occurrences of the substring "qu" in a word. O padrão de expressão regular \Bqu\w+ corresponde a uma subcadeia de caracteres que começa com um "qu" que não inicia uma palavra e que continua até o final da palavra.The regular expression pattern \Bqu\w+ matches a substring that begins with a "qu" that does not start a word and that continues to the end of the word.

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 da expressão regular é interpretado conforme a tabela a seguir.The regular expression pattern is interpreted as shown in the following table.

PadrãoPattern DESCRIÇÃODescription
\B Não começa a correspondência em um limite de palavra.Do not begin the match at a word boundary.
qu Corresponde à subcadeia de caracteres “qu”.Match the substring "qu".
\w+ Corresponde a um ou mais caracteres de palavra.Match one or more word characters.

Consulte tambémSee also