Construtores de alternância em expressões regularesAlternation Constructs in Regular Expressions

Os constructos de alternância modificam uma expressão regular para permitir uma correspondência condicional ou do tipo um/ou outro.Alternation constructs modify a regular expression to enable either/or or conditional matching. O .NET dá suporte a três constructos de alternância:.NET supports three alternation constructs:

Correspondência de padrões com |Pattern Matching with |

Você pode usar o caractere de barra vertical (|) para corresponder a qualquer um de uma série de padrões, no qual o caractere | separa cada padrão.You can use the vertical bar (|) character to match any one of a series of patterns, where the | character separates each pattern.

Como a classe de caracteres positivos, o caractere | pode ser usado para corresponder a qualquer um de vários caracteres únicos.Like the positive character class, the | character can be used to match any one of a number of single characters. O exemplo a seguir usa uma classe de caracteres positivos e um padrão do tipo um/ou outro correspondendo ao caractere | para localizar ocorrências das palavras “gray” ou “grey” em uma cadeia de caracteres.The following example uses both a positive character class and either/or pattern matching with the | character to locate occurrences of the words "gray" or "grey" in a string. Nesse caso, o caractere | produz uma expressão regular que é mais detalhada.In this case, the | character produces a regular expression that is more verbose.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Regular expression using character class.
      string pattern1 = @"\bgr[ae]y\b";
      // Regular expression using either/or.
      string pattern2 = @"\bgr(a|e)y\b";

      string input = "The gray wolf blended in among the grey rocks.";
      foreach (Match match in Regex.Matches(input, pattern1))
         Console.WriteLine("'{0}' found at position {1}",
                           match.Value, match.Index);
      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern2))
         Console.WriteLine("'{0}' found at position {1}",
                           match.Value, match.Index);
   }
}
// The example displays the following output:
//       'gray' found at position 4
//       'grey' found at position 35
//
//       'gray' found at position 4
//       'grey' found at position 35
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        ' Regular expression using character class.
        Dim pattern1 As String = "\bgr[ae]y\b"
        ' Regular expression using either/or.
        Dim pattern2 As String = "\bgr(a|e)y\b"

        Dim input As String = "The gray wolf blended in among the grey rocks."
        For Each match As Match In Regex.Matches(input, pattern1)
            Console.WriteLine("'{0}' found at position {1}", _
                              match.Value, match.Index)
        Next
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, pattern2)
            Console.WriteLine("'{0}' found at position {1}", _
                              match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       'gray' found at position 4
'       'grey' found at position 35
'       
'       'gray' found at position 4
'       'grey' found at position 35           

A expressão regular | que \bgr(a|e)y\busa o caractere é interpretada como mostrado na tabela a seguir:The regular expression that uses the | character, \bgr(a|e)y\b, is interpreted as shown in the following table:

PadrãoPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
gr Corresponder aos caracteres "gr".Match the characters "gr".
(a|e) Corresponder a um "a" ou "e".Match either an "a" or an "e".
y\b Corresponder a um “y” em um limite de palavra.Match a "y" on a word boundary.

O caractere | também pode ser usado para executar uma correspondência do tipo um/ou outro com vários caracteres ou subexpressões, que podem incluir qualquer combinação de literais de caracteres e elementos de linguagem de expressão regular.The | character can also be used to perform an either/or match with multiple characters or subexpressions, which can include any combination of character literals and regular expression language elements. (A classe de caracteres não fornece essa funcionalidade.) O exemplo a | seguir usa o caractere para extrair um Número de Segurança Social dos EUA (SSN), que é um número de 9 dígitos com o formato ddd-ddddd**dd-, ou um Número de Identificação do Empregador dos EUA (EIN), que é um número de 9 dígitos com o formato dd-dddddd.(The character class does not provide this functionality.) The following example uses the | character to extract either a U.S. Social Security Number (SSN), which is a 9-digit number with the format ddd-dd-dddd, or a U.S. Employer Identification Number (EIN), which is a 9-digit number with the format dd-ddddddd.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b"
        Dim input As String = "01-9999999 020-333333 777-88-9999"
        Console.WriteLine("Matches for {0}:", pattern)
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
'          01-9999999 at position 0
'          777-88-9999 at position 22

A expressão \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b regular é interpretada conforme mostrado na tabela a seguir:The regular expression \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b is interpreted as shown in the following table:

PadrãoPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
(\d{2}-\d{7}|\d{3}-\d{2}-\d{4}) Corresponde a uma das seguintes opções: dois dígitos decimais seguidos por um hífen seguido por sete dígitos decimais ou três dígitos decimais, um hífen, dois dígitos decimais, outro hífen e quatro dígitos decimais.Match either of the following: two decimal digits followed by a hyphen followed by seven decimal digits; or three decimal digits, a hyphen, two decimal digits, another hyphen, and four decimal digits.
\d Termina a correspondência em um limite de palavra.End the match at a word boundary.

Correspondência condicional com uma expressãoConditional matching with an expression

Este elemento de linguagem tenta corresponder a um dos dois padrões dependendo de se ele pode corresponder a um padrão inicial.This language element attempts to match one of two patterns depending on whether it can match an initial pattern. Sua sintaxe é:Its syntax is:

(?(expressão ) sim | não)(?( expression ) yes | no )

onde a expressão é o padrão inicial para combinar, sim é o padrão para combinar se a expressão for combinada, e não é o padrão opcional para combinar se a expressão não for correspondida.where expression is the initial pattern to match, yes is the pattern to match if expression is matched, and no is the optional pattern to match if expression is not matched. O mecanismo de expressões regulares trata a expressão como uma asserção de largura zero, isto é, o mecanismo de expressões regulares não avança no fluxo de entrada após avaliar a expressão.The regular expression engine treats expression as a zero-width assertion; that is, the regular expression engine does not advance in the input stream after it evaluates expression. Portanto, esse constructo é equivalente ao seguinte:Therefore, this construct is equivalent to the following:

(?(?=expressão ) sim | não)(?(?= expression ) yes | no )

onde (?= a expressão ) é uma construção de afirmação de largura zero.where (?=expression) is a zero-width assertion construct. (Para obter mais informações, consulte Grouping Constructs.) Como o mecanismo de expressão regular interpreta a expressão como uma âncora (uma afirmação de largura zero), a expressão deve ser uma afirmação de largura zero (para mais informações, ver Âncoras) ou uma subexpressão que também está contida em sim.(For more information, see Grouping Constructs.) Because the regular expression engine interprets expression as an anchor (a zero-width assertion), expression must either be a zero-width assertion (for more information, see Anchors) or a subexpression that is also contained in yes. Caso contrário, o padrão sim não pode ser correspondido.Otherwise, the yes pattern cannot be matched.

Observação

Se a expressão for um grupo de captura nomeado ou numerado, o construto de alternância será interpretado como um teste de captura; para obter mais informações, consulte a próxima seção, Correspondência condicional com base em um grupo de captura válido.If expression is a named or numbered capturing group, the alternation construct is interpreted as a capture test; for more information, see the next section, Conditional Matching Based on a Valid Capture Group. Em outras palavras, o mecanismo de expressões regulares não tenta corresponder a subcadeia de caracteres capturada, mas em vez disso, testa a presença ou ausência do grupo.In other words, the regular expression engine does not attempt to match the captured substring, but instead tests for the presence or absence of the group.

O exemplo a seguir é uma variação do exemplo que aparece na seção E/Ou Correspondência de Padrões com |.The following example is a variation of the example that appears in the Either/Or Pattern Matching with | section. Ele usa a correspondência condicional para determinar se os três primeiros caracteres após um limite de palavra são dois dígitos seguidos por um hífen.It uses conditional matching to determine whether the first three characters after a word boundary are two digits followed by a hyphen. Se forem, ele tenta corresponder a um Número de Identificação do Empregador dos EUA (EIN).If they are, it attempts to match a U.S. Employer Identification Number (EIN). Caso assim, ele tenta igualar um Número de Segurança Social dos EUA (SSN).If not, it attempts to match a U.S. Social Security Number (SSN).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Matches for \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b"
        Dim input As String = "01-9999999 020-333333 777-88-9999"
        Console.WriteLine("Matches for {0}:", pattern)
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Matches for \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b:
'          01-9999999 at position 0
'          777-88-9999 at position 22

O padrão \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b de expressão regular é interpretado conforme mostrado na tabela a seguir:The regular expression pattern \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b is interpreted as shown in the following table:

PadrãoPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
(?(\d{2}-) Determinar se os próximos três caracteres são compostos por dois dígitos seguidos por um hífen.Determine whether the next three characters consist of two digits followed by a hyphen.
\d{2}-\d{7} Se o padrão anterior corresponder, corresponder a dois dígitos seguidos por um hífen seguido por sete dígitos.If the previous pattern matches, match two digits followed by a hyphen followed by seven digits.
\d{3}-\d{2}-\d{4} Se o padrão anterior não corresponder, corresponder a três dígitos decimais, um hífen, dois dígitos decimais, outro hífen e quatro dígitos decimais.If the previous pattern does not match, match three decimal digits, a hyphen, two decimal digits, another hyphen, and four decimal digits.
\b Corresponder a um limite de palavra.Match a word boundary.

Correspondência condicional com base em um grupo capturado válidoConditional matching based on a valid captured group

Este elemento de linguagem tenta corresponder a um dos dois padrões dependendo de se ele correspondeu a um grupo de captura especificado.This language element attempts to match one of two patterns depending on whether it has matched a specified capturing group. Sua sintaxe é:Its syntax is:

(?( nome ) sim | não )(?( name ) yes | no )

ouor

(?(número ) sim | não)(?( number ) yes | no )

onde o nome é o nome e o número é o número de um grupo de captura, sim é a expressão para combinar se nome ou número tiver uma correspondência, e não é a expressão opcional para combinar se não tiver.where name is the name and number is the number of a capturing group, yes is the expression to match if name or number has a match, and no is the optional expression to match if it does not.

Se name não corresponder ao nome de um grupo de captura que é usado no padrão de expressão regular, o constructo de alternância será interpretado como teste de expressão, conforme explicado na seção anterior.If name does not correspond to the name of a capturing group that is used in the regular expression pattern, the alternation construct is interpreted as an expression test, as explained in the previous section. Normalmente, isso expression significa que falsea expressão avalia para .Typically, this means that expression evaluates to false. Se number não corresponder a um grupo de captura numerado que é usado no padrão de expressão regular, o mecanismo de expressões regulares gerará um ArgumentException.If number does not correspond to a numbered capturing group that is used in the regular expression pattern, the regular expression engine throws an ArgumentException.

O exemplo a seguir é uma variação do exemplo que aparece na seção E/Ou Correspondência de Padrões com |.The following example is a variation of the example that appears in the Either/Or Pattern Matching with | section. Ele usa um grupo de captura chamado n2 que consiste em dois dígitos seguidos por um hífen.It uses a capturing group named n2 that consists of two digits followed by a hyphen. O constructo de alternância testa se este grupo de captura foi correspondido na cadeia de caracteres de entrada.The alternation construct tests whether this capturing group has been matched in the input string. Se tiver, a construção de alternância tenta corresponder aos últimos sete dígitos de um Número de Identificação do Empregador (EIN) de nove dígitos.If it has, the alternation construct attempts to match the last seven digits of a nine-digit U.S. Employer Identification Number (EIN). Caso não tenha, ele tenta igualar um Número de Segurança Social (SSN) de nove dígitos.If it has not, it attempts to match a nine-digit U.S. Social Security Number (SSN).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Matches for \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b"
        Dim input As String = "01-9999999 020-333333 777-88-9999"
        Console.WriteLine("Matches for {0}:", pattern)
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
    End Sub
End Module

O padrão \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b de expressão regular é interpretado conforme mostrado na tabela a seguir:The regular expression pattern \b(?<n2>\d{2}-)?(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b is interpreted as shown in the following table:

PadrãoPattern DescriçãoDescription
\b Iniciar em um limite de palavra.Start at a word boundary.
(?<n2>\d{2}-)? Corresponder a zero ou uma ocorrência de dois dígitos seguidos por um hífen.Match zero or one occurrence of two digits followed by a hyphen. Atribua um nome ao grupo de captura n2.Name this capturing group n2.
(?(n2) Testar se n2 foi correspondido na cadeia de caracteres de entrada.Test whether n2 was matched in the input string.
\d{7} Se n2 tiver sido correspondido, corresponder a sete dígitos decimais.If n2 was matched, match seven decimal digits.
|\d{3}-\d{2}-\d{4} Se n2 não tiver sido correspondido, corresponder a três dígitos decimais, um hífen, dois dígitos decimais, outro hífen e quatro dígitos decimais.If n2 was not matched, match three decimal digits, a hyphen, two decimal digits, another hyphen, and four decimal digits.
\b Corresponder a um limite de palavra.Match a word boundary.

Uma variação desse exemplo que usa um grupo numerado em vez de um grupo nomeado é mostrada no exemplo a seguir.A variation of this example that uses a numbered group instead of a named group is shown in the following example. O padrão da expressão regular é \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b.Its regular expression pattern is \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b";
      string input = "01-9999999 020-333333 777-88-9999";
      Console.WriteLine("Matches for {0}:", pattern);
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("   {0} at position {1}", match.Value, match.Index);
   }
}
// The example display the following output:
//       Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
//          01-9999999 at position 0
//          777-88-9999 at position 22
Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b"
        Dim input As String = "01-9999999 020-333333 777-88-9999"
        Console.WriteLine("Matches for {0}:", pattern)
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("   {0} at position {1}", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Matches for \b(\d{2}-)?(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b:
'          01-9999999 at position 0
'          777-88-9999 at position 22

Confira tambémSee also