Construtores de Alternância

Construções de alternação modificar uma expressão regular para habilitar um / ou correspondência condicional ou. A.NET Framework oferece suporte a três construções de alternação:

• Padrões coincidentes com |

• Correspondência condicional com (? (Yes | de expressão))

• Correspondência condicional com base em um grupo de capturados válido

Padrões coincidentes com |

Você pode usar o vertical (de barra.|) caracteres para corresponder a qualquer um de uma série de padrões, onde o | caractere que separa cada padrão.

Como a classe de caracteres de positivo, o |caractere pode ser usado para coincidir com qualquer um de um número de caracteres único. O exemplo a seguir usa uma classe de caracteres positivo e um / ou correspondência de padrões com o |caractere para localizar as ocorrências das palavras "gato" ou "pato" em uma seqüência de caracteres. Nesse caso, o | caractere produz uma expressão regular que é mais detalhada.

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           

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           

A expressão regular que usa o | caractere, \bgr(a|e)y\b, que é interpretado como mostrado na tabela a seguir.

O |caractere também pode ser usado para realizar uma / ou coincide com vários caracteres ou subexpressões, que podem incluir qualquer combinação de literais de caractere e elementos de linguagem de expressão regular. (A classe de caracteres não fornece essa funcionalidade.) O exemplo a seguir usa o |caractere para extrair qualquer dos EUA Número da previdência social (SSN), que é um número de 9 dígitos com o formato ddd-dd-dddd, ou dos EUA Número de identificação de empregador (EIN), que é um número de 9 dígitos com o formato dd-ddddddd.

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

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

A expressão regular \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b é interpretado como mostrado na tabela a seguir.

Voltar ao topo

Condicional correspondência com uma expressão

O elemento de linguagem tenta corresponder a um dos dois padrões, dependendo se ele pode corresponder a um padrão inicial. Sua sintaxe é:

(?(expressão)Sim|não)

onde expressão é o padrão inicial para corresponder, Sim é o padrão de correspondência se expressão for atendida, e sem é o padrão de opcional para corresponder ao se expressão não corresponde. O mecanismo de expressão regular trata expressão como uma declaração de largura zero; ou seja, o mecanismo de expressão regular não Avançar no fluxo de entrada após ele avalia expressão. Portanto, essa construção é equivalente à seguinte:

(?(?=expressão)Sim|não)

onde (?=expressão) é uma construção de declaração de largura igual a zero. (Para obter mais informações, consulte Agrupando Construtores.) Porque o mecanismo de expressão regular interpreta expressão como uma âncora (uma declaração de largura zero), expressão deve ser uma afirmação de largura zero (para obter mais informações, consulte Âncoras de expressões regulares) ou uma subexpressão que também está contida no Sim. Caso contrário, o Sim padrão não pode ser correspondido.

O exemplo a seguir é uma variação do que aparece no exemplo de ou / ou correspondência de padrões com | seção. 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. Se estiverem, ele tenta corresponder a dos EUA Número de identificação de empregador (EIN). Caso contrário, ele tenta corresponder a dos EUA Número do CPF (cadastro de pessoas físicas).

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

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

O padrão de expressão regular \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b é interpretado como mostrado na tabela a seguir.

Voltar ao topo

Correspondência condicional com base em um grupo de capturados válido

O elemento de linguagem tenta corresponder a um dos dois padrões, dependendo se ele pode corresponder a um grupo de capturados especificado. Sua sintaxe é:

(?(nome)Sim|não)

ou

(?(número)Sim|não)

onde nome é o nome e número é o número de um grupo de captura, Sim é a expressão para corresponder ao se nome ou número tem uma correspondência e sem é a expressão opcional para coincidir com o se ele não.

Se nome não corresponde ao nome de um grupo de captura é usado no padrão de expressão regular, a construção de alternação é interpretada como um teste de expressão, conforme explicado na seção anterior. Geralmente, isso significa que expressão for avaliada como false. Se número não corresponde a um grupo de captura numerado que é usado no padrão de expressão regular, a lança de mecanismo de expressão regular uma ArgumentException.

O exemplo a seguir é uma variação do que aparece no exemplo de ou / ou correspondência de padrões com | seção. Ele usa um grupo de captura chamado n2 que consiste em dois dígitos seguidos por um hífen. A alternação construir testes se o grupo de captura foi encontrado na seqüência de entrada. Em caso afirmativo, a alternação construir tenta coincidir com os últimos sete dígitos dos EUA Número de identificação de empregador (EIN). Se não tiver, ele tenta corresponder a dos EUA Número do CPF (cadastro de pessoas físicas).

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

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

O padrão de expressão regular \b(?<n2>\d{2}-)*(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b é interpretado como mostrado na tabela a seguir.

Uma variação desse exemplo que usa um grupo numerado em vez de um grupo nomeado é mostrada no exemplo a seguir. Seu padrão de expressão regular é \b(\d{2}-)*(?(1)\d{7}|\d{3}-\d{2}-\d{4})\b.

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

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

Voltar ao topo

Consulte também

Conceitos

Elementos de linguagem das expressões regulares