Partager via

Constructions d'alternative

  • Article

Les constructions d'alternative modifient une expression régulière pour permettre la correspondance de type inclusif/exclusif. Le .NET Framework prend en charge trois constructions d'alternative :

  • Critères spéciaux avec |

  • Correspondance conditionnelle avec (? (expression) oui | non)

  • Correspondance conditionnelle selon un groupe capturé valide

Critères spéciaux avec |

Vous pouvez utiliser la barre verticale (|) caractère pour correspondre à une série de modèles, où le | le caractère sépare chaque modèle.

Comme la classe de caractères positive, le |le caractère peut être utilisé pour correspondre à tout nombre de caractères uniques. L'exemple suivant utilise une classe de caractères positive et des critères spéciaux either/or avec le |le caractère pour trouver des occurrences des mots « gris » ou « grisé » dans une chaîne. Dans ce cas, le | le caractère produit une expression régulière qui est plus détaillée.

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

Expression régulière qui utilise | le caractère, \bgr(a|e)y\b, est interprété comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencer à la limite d'un mot.

gr

Mettre en correspondance les caractères « gr ».

(a|e)

Mettre en correspondance un « a » ou un « e ».

y\b

Mettre en correspondance un « y » sur une limite de mot.

La méthode |le caractère peut également être utilisé pour exécuter une correspondance et/ou avec plusieurs caractères ou sous-expressions, qui peuvent inclure toute combinaison de caractère littéraux et éléments de langage d'expressions régulières. (La classe de caractères ne fournit pas ces fonctionnalités.) L'exemple suivant utilise  : |caractère pour extraire ou un U.S. Numéro de sécurité sociale (SSN), qui est un nombre de 9 chiffres au format ddd-dd-dddd, ou un format américain. Numéro d'identification de l'employeur (EIN), qui est un nombre de 9 chiffres au format 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

L'expression régulière \b(\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b est interprétée comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencer à la limite d'un mot.

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

Mettre en correspondance l'un ou l'autre des éléments suivants : deux chiffres décimaux suivis d'un trait d'union suivi de sept chiffres décimaux, ou alors trois chiffres décimaux, un trait d'union, deux chiffres décimaux, un autre trait d'union et quatre chiffres décimaux.

\d

Terminez la correspondance à la limite d'un mot.

Retour au début

Correspondance conditionnelle avec une Expression

Cet élément de langage essaie de faire correspondre l'un de deux modèles selon qu'il peut correspondre à un modèle initial. La syntaxe est la suivante :

(?(expression)yes|non)

où expression est le modèle initial à faire correspondre, yes est le modèle à faire correspondre si l'expression est mise en correspondance, et no est le modèle facultatif à faire correspondre si l'expression n'est pas mise en correspondance. Le moteur d'expressions régulières traite l'expression comme une assertion de largeur nulle ; c'est-à-dire que le moteur d'expressions régulières n'avance pas dans le flux d'entrée après avoir évalué l'expression. Par conséquent, cette construction est équivalente aux éléments suivants :

(?(?=expression)oui|non)

où (?=expression) est une construction d'assertion de largeur nulle. (Pour plus d'informations, consultez Constructions de regroupement). Étant donné que le moteur des expressions régulières interprète l'expression comme une ancre (assertion de largeur nulle), l'expression doit être soit une assertion de largeur nulle (pour plus d'informations, consultez Ancres dans les expressions régulières) soit une sous-expression qui est également contenue dans oui. Sinon, le modèle oui ne peut pas être mis en correspondance.

RemarqueRemarque

Si l'expression est un groupe de capture nommé ou numéroté, la construction alternative est interprétée comme un test de capture ; pour plus d'informations, consultez la section suivante, Correspondance conditionnelle selon un groupe capturé valide.En d'autres termes, le moteur des expressions régulières n'essaie pas de correspondre à la sous-chaîne capturée, mais à la place teste la présence ou l'absence du groupe.

L'exemple suivant est une variation de l'exemple dans lequel s'affiche la section Critères spéciaux avec |. Il utilise la mise en correspondance conditionnelle pour déterminer si les trois premiers caractères après une limite de mot sont deux chiffres suivis d'un trait d'union. S'ils sont, il essaie de correspondre à un U.S. Numéro d'identification de l'employeur (EIN). Si pas, il essaie de correspondre à un U.S. Numéro de sécurité sociale américain (SSN, Social Security Number).

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

Le modèle d'expression régulière \b(?(\d{2}-)\d{2}-\d{7}|\d{3}-\d{2}-\d{4})\b est interprété comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencer à la limite d'un mot.

(?(\d{2}-)

Déterminez si les trois caractères suivants se composent de deux chiffres suivis par un trait d'union.

\d{2}-\d{7}

Si le modèle précédent correspond, faites correspondre deux chiffres suivis par un trait d'union suivi par sept chiffres.

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

Si le modèle précédent ne correspond pas, faites correspondre trois chiffres décimaux, un trait d'union, deux chiffres décimaux, un autre trait d'union et quatre chiffres décimaux.

\b

Mettre en correspondance la limite d'un mot.

Retour au début

Correspondance conditionnelle selon un groupe capturé valide

Cet élément de langage essaie de faire correspondre l'un de deux modèles selon qu'il peut correspondre à un groupe capturé spécifié. La syntaxe est la suivante :

(?(nom)yes|non)

ou

(?(nombre)yes|non)

où name est le nom et number est le numéro d'un groupe de capture, yes est l'expression à faire correspondre si name ou number a une correspondance et no est l'expression facultative à faire correspondre dans le cas contraire.

Si le nom ne correspond pas au nom d'un groupe de capture utilisé dans le modèle d'expression régulière, la construction alternative est interprétée comme un test d'expression, comme expliqué dans la section précédente. En général, cela signifie que l'expression prend la valeur false. Si le nombre ne correspond pas à un groupe de capture compté utilisé dans le modèle d'expression régulière, le moteur des expressions régulières lève une exception ArgumentException.

L'exemple suivant est une variation de l'exemple dans lequel s'affiche la section Critères spéciaux avec |. Il utilise un groupe de capture nommé n2 qui se compose de deux chiffres suivis d'un trait d'union. La construction d'alternative teste si ce groupe de capture a été mis en correspondance dans la chaîne d'entrée. S'il a, la construction d'alternative essaie de correspondre aux sept derniers chiffres d'un U.S. Numéro d'identification de l'employeur (EIN). S'il n'a pas, il essaie de correspondre à un U.S. Numéro de sécurité sociale américain (SSN, Social Security Number).

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

Le modèle d'expression régulière \b(?<n2>\d{2}-)*(?(n2)\d{7}|\d{3}-\d{2}-\d{4})\b est interprété comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencer à la limite d'un mot.

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

Mettre en correspondance zéro ou une occurrence de deux chiffres suivis d'un trait d'union. Nommez ce n2 de groupe de capture.

(?(n2)

Testez si n2 est mis en correspondance dans la chaîne d'entrée.

)\d{7}

Si n2 est mis en correspondance, faites correspondre sept chiffres décimaux.

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

Si n2 ne correspond pas, faites correspondre trois chiffres décimaux, un trait d'union, deux chiffres décimaux, un autre trait d'union et quatre chiffres décimaux.

\b

Mettre en correspondance la limite d'un mot.

Une variation de cet exemple qui utilise un groupe numéroté au lieu d'un groupe nommé est affichée dans l'exemple suivant. Son modèle d'expression régulière est \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

Retour au début

Voir aussi

Concepts

Éléments du langage des expressions régulières