Compartir a través de

Construcciones de alternancia

  • Artículo

Las estructuras de alternancia modifican una expresión regular para habilitar o no la coincidencia condicional. .NET Framework admite tres construcciones de alternancia:

  • Coincidencia de modelos con |

  • Concordancia condicional con (?(expression)yes|no)

  • Concordancia condicional basada en un grupo capturado válido

Coincidencia de modelos con |

Puede utilizar la barra vertical (|) carácter para coincidir con cualquiera modelo de una serie de modelos, donde | el carácter separa cada modelo.

Al igual que la clase de caracteres positivos, el |el carácter se puede utilizar para buscar coincidencias con cualquiera de varios caracteres individuales. En el siguiente ejemplo se utiliza una clase de caracteres positiva y coincidencia de modelos either/or con |el carácter para buscar apariciones de las palabras se "gray" o "grey" en una cadena. En este caso, | el carácter genera una expresión regular más detallada.

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

La expresión regular que usa | el carácter \bgr(a|e)y\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Empezar en un límite de palabras.

gr

Busca una coincidencia con los caracteres "gr".

(a|e)

Busca una coincidencia de una "a" o una "e".

y\b

Busca una coincidencia con una "y" en un límite de palabra.

El |el carácter también se puede utilizar para buscar una coincidencia con varios caracteres o subexpresiones, que pueden incluir cualquier combinación de literales de carácter y elementos del lenguaje de expresión regular. (La clase de caracteres no proporciona esta funcionalidad.) En el ejemplo siguiente se usa el |carácter para extraer Number de la seguridad social, que es un número de 9 dígitos con el formato ddd-dd-dddd o un Número de identificación de empleado, que es un número de 9 dígitos con 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

La expresión regular \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Empezar en un límite de palabras.

(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})

Busca una coincidencia de cualquiera de estas dos opciones: dos dígitos decimales seguidos de un guión seguido de siete dígitos decimales; o tres dígitos decimales, un guión, dos dígitos decimales, otro guión y cuatro dígitos decimales.

\d

Finalizar la búsqueda de coincidencias en un límite de palabras.

Volver al principio

Concordancia condicional con una expresión

Este elemento del lenguaje intenta coincidir con uno de dos modelos dependiendo de si puede coincidir con un modelo inicial. Su sintaxis es la siguiente:

(?(expression)yes|no)

donde expresión es el modelo inicial para la coincidencia, sí es el modelo para la coincidencia si se coincide con expresión y no es el modelo opcional para la coincidencia si no se coincide con expresión. El motor de expresiones regulares trata expresión como una aserción de ancho cero; es decir, el motor de expresiones regulares no avanza en el flujo de entrada después de evaluar expresión. Por consiguiente, esta construcción es equivalente a la siguiente:

(?(?=expression)yes|no)

donde (?=expresión) es una construcción de aserción de ancho cero. (Para obtener más información, vea Construcciones de agrupamiento). Dado que el motor de expresiones regulares interpreta la expresión como un anclaje (una aserción de ancho cero), la expresión debe ser una aserción de ancho cero (para obtener más información, vea Delimitadores en expresiones regulares) o una subexpresión que también está contenida en yes. De lo contrario, no se puede encontrar ninguna coincidencia con el modelo sí.

NotaNota

Si expresión es un grupo de capturas numerado o con nombre, la construcción de alternancia se interpreta como una prueba de captura; para obtener más información, vea la sección siguiente, Concordancia condicional basada en un grupo capturado válido.En otras palabras, el motor de expresiones regulares no intenta buscar una coincidencia con la subcadena capturada sino que comprueba la presencia o la ausencia del grupo.

El siguiente ejemplo es una variación del ejemplo que aparece en la sección Coincidencia de modelos con |. Utiliza la concordancia condicional para determinar si los tres primeros caracteres después de un límite de palabra son dos dígitos seguidos de un guión. En caso afirmativo, intenta buscar una coincidencia con Número de identificación de usuario (EIN). De lo contrario, intenta buscar una coincidencia con Número de la seguridad social (NSS).

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

El modelo de expresión regular \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Empezar en un límite de palabras.

(?(\d{2}-)

Determine si los tres caracteres siguientes están compuestos de dos dígitos seguidos por un guión.

\d{2}-\d{7}

Si se encuentra una coincidencia con el modelo anterior, se buscará una coincidencia con dos dígitos seguidos de un guión seguido de siete dígitos.

\d{3}-\d{2}-\d{4}

Si no se encuentra ninguna coincidencia con el modelo anterior, se deben buscar coincidencias con tres dígitos decimales, un guión, dos dígitos decimales, otro guión y cuatro dígitos decimales.

\b

Hacer coincidir con un límite de palabras.

Volver al principio

Concordancia condicional basada en un grupo capturado válido

Este elemento del lenguaje intenta coincidir con uno de dos modelos dependiendo de si puede coincidir con un grupo capturado especificado. Su sintaxis es la siguiente:

(?(nombre)yes|no)

o

(?(número)yes|no)

donde nombre es el nombre y número es el número de un grupo capturador, sí es la expresión para la coincidencia si nombre o número tiene una coincidencia y no es la expresión opcional para la coincidencia si no hay coincidencia.

Si nombre no se corresponde con el nombre del grupo de capturas utilizado en el modelo de expresión regular, la construcción de alternancia se interpreta como una prueba de expresión, tal y como se explica en la sección anterior. Normalmente, esto significa que expresión se evalúa como false. Si número no se corresponde con el grupo de capturas numerado utilizado en el modelo de expresión regular, el motor de expresiones regulares iniciará una excepción ArgumentException.

El siguiente ejemplo es una variación del ejemplo que aparece en la sección Coincidencia de modelos con |. Utiliza un grupo de capturas denominado n2 que se compone de dos dígitos seguidos de un guión. La construcción de alternancia prueba si este grupo capturador coincide en la cadena de entrada. En caso afirmativo, la construcción de alternancia intenta buscar una coincidencia con los últimos siete dígitos de un Número de identificación de usuario (EIN). De lo contrario, intenta buscar una coincidencia con Número de la seguridad social (NSS).

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

El modelo de expresión regular \b(?<n2>\d{2}-)*(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b se interpreta como se muestra en la tabla siguiente.

Modelo

Descripción

\b

Empezar en un límite de palabras.

(?<n2>\d{2}-)*

Busca cero o una coincidencia con dos dígitos seguidos de un guión. Asigne a este grupo de capturas el nombre n2.

(?(n2)

Pruebe si se encuentra n2 en la cadena de entrada.

)\d{7}

Si se encuentra una coincidencia con n2, se deben buscar coincidencias con siete dígitos decimales.

|\d{3}-\d{2}-\d{4}

Si no se encuentra ninguna coincidencia con n2, se deben buscar coincidencias con tres dígitos decimales, un guión, dos dígitos decimales, otro guión y cuatro dígitos decimales.

\b

Hacer coincidir con un límite de palabras.

Una variación de este ejemplo que utiliza un grupo numerado en lugar de un grupo con nombre se muestra en el siguiente ejemplo. Su modelo de expresión regular es \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

Volver al principio

Vea también

Conceptos

Elementos del lenguaje de expresiones regulares