Partager via

Options des expressions régulières

  • Article

Par défaut, la comparaison d'une chaîne d'entrée avec les caractères littéraux dans un modèle d'expression régulière respecte la casse, l'espace blanc dans un modèle d'expression régulière est interprété comme des caractères d'espace blanc littéraux, et les groupes de capture dans une expression régulière sont nommés implicitement ainsi qu'explicitement. Vous pouvez modifier ces aspects du comportement d'expression régulière par défaut et d'autres en spécifiant des options d'expression régulière. Ces options, qui sont répertoriées dans le tableau suivant, peuvent être incluses inline dans le cadre du modèle d'expression régulière, ou être fournies à un constructeur de classe System.Text.RegularExpressions.Regex ou une méthode de critères spéciaux statique comme une valeur d'énumération System.Text.RegularExpressions.RegexOptions.

Membre RegexOptions

Caractère inline

Effet

None

Non disponible

Utilisez le comportement par défaut. Pour plus d'informations, consultez Options par défaut.

IgnoreCase

i

Utilisez la correspondance qui ne respecte pas la casse Pour plus d'informations, consultez Correspondance qui ne respecte pas la casse.

Multiline

m

Utilisez le mode multiligne, où ^ et $ correspondent au début et fin de chaque ligne (au lieu du début et de la fin de la chaîne d'entrée). Pour plus d'informations, consultez Mode Multiligne.

Singleline

s

Utilisez le mode sur une ligne, où le point (.) correspond à chaque caractère (au lieu de chaque caractère sauf \n). Pour plus d'informations, consultez Mode sur une ligne.

ExplicitCapture

n

Ne capturez pas de groupes sans nom. Les seules captures valides sont des groupes explicitement nommés ou numérotés du formulaire (?<nom> sous-expression). Pour plus d'informations, consultez Captures explicites uniquement.

Compiled

Non disponible

Compile l'expression régulière en un assembly. Pour plus d'informations, consultez Expressions régulières Compilées.

IgnorePatternWhitespace

x

Exclue l'espace blanc sans séquence d'échappement du modèle et active les commentaires après un signe dièse (#). Pour plus d'informations, consultez Ignorer les espaces blancs.

RightToLeft

Non disponible

Modifie le sens de la recherche. La recherche se déplace de droite à gauche au lieu de gauche à droite. Pour plus d'informations, consultez Mode d'affichage de droite à gauche.

ECMAScript

Non disponible

Active un comportement conforme à ECMAScript pour l'expression. Pour plus d'informations, consultez Comportement correspondant à ECMAScript.

CultureInvariant

Non disponible

Ignorez les différences culturelles de la langue. Pour plus d'informations, consultez Comparaison à l'aide de la culture dite indifférente.

Spécification d'options

Vous pouvez spécifier des options pour les expressions régulières de l'une des trois manières suivantes :

  • Dans le paramètre options d'un constructeur de classe System.Text.RegularExpressions.Regex ou d'une méthode statique utilisant des critères spéciaux (Shared en Visual Basic), telle que Regex.Regex(String, RegexOptions) ou Regex.Match(String, String, RegexOptions). Le paramètre options est une combinaison de bits OR des valeurs énumérées System.Text.RegularExpressions.RegexOptions.

    L'exemple suivant illustre cette situation. Il utilise le paramètre options de la méthode Regex.Match(String, String, RegexOptions) pour permettre la correspondance ne respectant pas la casse et ignorer l'espace blanc de modèle lors de l'identification des mots commençant par la lettre « d ».

    Dim pattern As String = "d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."
Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace

For Each match As Match In Regex.Matches(input, pattern, options)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

    string pattern = @"d \w+ \s";
string input = "Dogs are decidedly good pets.";
RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace;

foreach (Match match in Regex.Matches(input, pattern, options))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

  • En appliquant des options inline dans un modèle d'expression régulière avec la syntaxe (?imnsx-imnsx). L'option s'applique au modèle depuis le point au niveau duquel l'option est définie jusqu'à la fin du modèle ou jusqu'au point au niveau duquel l'option est indéfinie par une autre option inline. Pour plus d'informations, consultez la rubrique Constructions diverses.

    L'exemple suivant illustre cette situation. Il utilise des options inline pour permettre une correspondance ne respectant pas la casse et ignorer l'espace blanc de modèle lors de l'identification des mots commençant par la lettre « d ».

    Dim pattern As String = "\b(?ix) d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

    string pattern = @"(?ix) d \w+ \s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

  • En appliquant des options inline à une construction de regroupement particulière dans un modèle d'expression régulière avec la syntaxe (?imnsx-imnsx:sous-expression). Aucun signe avant un ensemble d'options active l'ensemble ; un signe moins avant un ensemble d'options désactive l'ensemble. (? est une partie fixe de la syntaxe de la construction de langage qui est obligatoire si les options sont activées ou désactivées.) L'option s'applique uniquement à ce groupe. Pour plus d'informations, consultez Constructions de regroupement.

    L'exemple suivant illustre cette situation. Il utilise des options inline dans une construction de regroupement pour permettre une correspondance ne respectant pas la casse et ignorer l'espace blanc de modèle lors de l'identification des mots commençant par la lettre « d ».

    Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
   Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      

    string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
   Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Si les options sont spécifiées inline, un signe moins (-) avant une option ou un groupe d'options désactive celles-ci. Par exemple, la construction inline (?ix-ms) active les options RegexOptions.IgnoreCase et RegexOptions.IgnorePatternWhitespace et désactive les options RegexOptions.Multiline et RegexOptions.Singleline. Toutes les options des expressions régulières sont désactivées par défaut.

RemarqueRemarque

Si les options d'expression régulière spécifiées dans le paramètre options d'un constructeur ou d'un appel de méthode sont en conflit avec les options spécifiées inline dans un modèle d'expression régulière, les options inline sont utilisées.

Les cinq options d'expression régulière suivantes peuvent être définies à la fois avec le paramètre d'options et inline :

Les cinq options d'expression régulière suivantes peuvent être définies à l'aide du paramètre options mais ne peuvent pas être définies inline :

Détermination des options

Vous pouvez déterminer les options qui ont été fournies à un objet Regex lorsqu'il a été instancié en récupérant la valeur de la propriété Regex.Options en lecture seule. Cette propriété est particulièrement utile pour la détermination des options définies pour une expression régulière compilée créée par la méthode Regex.CompileToAssembly.

Pour tester la présence de toute option sauf RegexOptions.None, exécutez une opération ET avec la valeur de la propriété Regex.Options et la valeur RegexOptions à laquelle vous vous intéressez. Testez ensuite si le résultat est égal à cette valeur RegexOptions. L'exemple suivant teste si l'option RegexOptions.IgnoreCase a été définie.

If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
   Console.WriteLine("Case-insensitive pattern comparison.")
Else
   Console.WriteLine("Case-sensitive pattern comparison.")
End If   

if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
   Console.WriteLine("Case-insensitive pattern comparison.");
else
   Console.WriteLine("Case-sensitive pattern comparison.");

Pour tester RegexOptions.None, déterminez si la valeur de la propriété Regex.Options est égale à RegexOptions.None, comme illustré dans l'exemple suivant.

If rgx.Options = RegexOptions.None Then
   Console.WriteLine("No options have been set.")
End If

if (rgx.Options == RegexOptions.None)
   Console.WriteLine("No options have been set.");

Les sections suivantes présentent les options pris en charge par les expressions régulières du .NET Framework.

Options par défaut

L'option RegexOptions.None indique qu'aucune option n'a été spécifiée, et le moteur des expressions régulières utilise son comportement par défaut. Notamment :

  • Le modèle est interprété comme canonique plutôt que comme une expression régulière ECMAScript.

  • Le modèle d'expression régulière est mis en correspondance de gauche à droite dans la chaîne d'entrée.

  • Les comparaisons respectent la casse.

  • Les éléments de langage $ et ^ correspondent au début et à la fin de la chaîne d'entrée.

  • L'élément de langage . correspond à tout caractère sauf \n.

  • Tout espace blanc dans un modèle d'expression régulière est interprété comme un espace littéral.

  • Les conventions de la culture actuelle sont utilisées lors de la comparaison du modèle à la chaîne d'entrée.

  • Les groupes de capture dans le modèle d'expression régulière sont implicites ainsi qu'explicite.

RemarqueRemarque

L'option RegexOptions.None n'a aucun équivalent inline.Lorsque les options d'expression régulière sont appliquées inline, le comportement par défaut est restauré sur option par option, en désactivant une option particulière.Par exemple, (?i) active la comparaison qui ne respecte pas la casse, et (?-i) restaure la comparaison qui respecte la casse par défaut.

Étant donné que l'option RegexOptions.None représente le comportement par défaut du moteur des expressions régulières, elle est rarement spécifiée explicitement dans un appel de méthode. Un constructeur ou méthode statique utilisant des critères spéciaux sans paramètre options est appelé à la place.

Retour au début

Correspondance qui ne respecte pas la casse

L'option IgnoreCase, ou l'option inline i, fournit la correspondance non sensible à la casse. Par défaut, les conventions de casse de la culture actuelle sont utilisées.

L'exemple suivant définit un modèle d'expression régulière, \bthe\w*\b, qui met en correspondance tous les mots commençant par « the ». Étant donné que le premier appel à la méthode Match utilise la comparaison qui respecte la casse par défaut, la sortie indique que la chaîne « The » qui commence la phrase n'est pas mise en correspondance. Il y a correspondance lorsque la méthode Match est appelée avec les options définies sur IgnoreCase.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bthe\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, _
                                               RegexOptions.IgnoreCase)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bthe\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

L'exemple suivant modifie le modèle d'expression régulière de l'exemple précédent pour utiliser des options inline au lieu du paramètre options pour fournir la comparaison qui ne respecte pas la casse. Le premier modèle définit l'option non sensible à la casse dans une construction de regroupement qui s'applique uniquement à la lettre « l » dans la chaîne « le ». Étant donné que la construction d'option se produit au début du modèle, le deuxième modèle applique l'option qui ne respecte pas la casse à l'ensemble de l'expression régulière.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?i:t)he\w*\b"
      Dim input As String = "The man then told them about that event."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
      Console.WriteLine()
      pattern = "(?i)\bthe\w*\b"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
      Next
   End Sub
End Module
' The example displays the following output:
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?i:t)he\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      pattern = @"(?i)\bthe\w*\b";
      foreach (Match match in Regex.Matches(input, pattern, 
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
//       
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Retour au début

Mode multiligne

L'option RegexOptions.Multiline, ou l'option inline m, permet au moteur des expressions régulières de gérer une chaîne d'entrée qui se compose de plusieurs lignes. Il modifie l'interprétation des éléments de langage $ et ^ afin qu'ils correspondent au début et à la fin d'une ligne, au lieu du début et de la fin de la chaîne d'entrée.

Par défaut, $ correspond uniquement à la fin de la chaîne d'entrée. Si vous spécifiez l'option RegexOptions.Multiline, cela correspond soit au caractère de saut de ligne (\n) soit à la fin de la chaîne d'entrée. Il ne correspond cependant pas à la combinaison retour chariot/saut de ligne. Pour les mettre en correspondance, utilisez la sous-expression \r?$ plutôt que la simple expression $.

L'exemple suivant extrait les noms et scores des joueurs de boules et les ajoute à une collection SortedList<TKey, TValue> qui les trie dans l'ordre décroissant. La méthode Matches est appelée deux fois. Dans le premier appel de méthode, l'expression régulière est ^(\w+)\s(\d+)$ et aucune option n'est définie. Comme le montre la sortie, étant donné que le moteur des expressions régulières ne peut pas faire correspondre le modèle d'entrée au début et à la fin de la chaîne d'entrée, aucune correspondance n'est trouvée. Dans le deuxième appel de méthode, l'expression régulière est modifiée en ^(\w+)\s(\d+)\r?$ et les options sont définies sur RegexOptions.Multiline. Comme le montre la sortie, les noms et les notes sont correctement mis en correspondance, et les notes sont affichées dans l'ordre décroissant.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())

      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "^(\w+)\s(\d+)$"
      Dim matched As Boolean = False

      Console.WriteLine("Without Multiline option:")
      For Each match As Match In Regex.Matches(input, pattern)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
         matched = True
      Next
      If Not matched Then Console.WriteLine("   No matches.")
      Console.WriteLine()

      ' Redefine pattern to handle multiple lines.
      pattern = "^(\w+)\s(\d+)\r*$"
      Console.WriteLine("With multiline option:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Without Multiline option:
'       No matches.
'    
'    With multiline option:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());

      string input = "Joe 164\n" + 
                     "Sam 208\n" + 
                     "Allison 211\n" + 
                     "Gwen 171\n"; 
      string pattern = @"^(\w+)\s(\d+)$";
      bool matched = false;

      Console.WriteLine("Without Multiline option:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);
         matched = true;
      }
      if (! matched)
         Console.WriteLine("   No matches.");
      Console.WriteLine();

      // Redefine pattern to handle multiple lines.
      pattern = @"^(\w+)\s(\d+)\r*$";
      Console.WriteLine("With multiline option:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Int32.Parse(match.Groups[2].Value), (string) match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y)
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//   Without Multiline option:
//      No matches.
//   
//   With multiline option:
//   Allison: 211
//   Sam: 208
//   Gwen: 171
//   Joe: 164

Le modèle d'expression régulière ^(\w+)\s(\d+)\r*$ est défini comme indiqué dans le tableau suivant.

Modèle

Description

^

Commencer au début de la ligne.

(\w+)

Mettre en correspondance un ou plusieurs caractères alphabétiques. Il s'agit du premier groupe de capture.

\s

Mettre en correspondance un espace blanc.

(\d+)

Mettre en correspondance un ou plusieurs chiffres décimaux. Il s'agit du deuxième groupe de capture.

\r?

Correspond à zéro ou à un caractère de retour chariot.

$

Terminaison en fin de ligne.

L'exemple suivant est équivalent au précédent, mais il utilise l'option inline (?m) pour définir l'option multiligne.

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())

      Dim input As String = "Joe 164" + vbCrLf + _
                            "Sam 208" + vbCrLf + _
                            "Allison 211" + vbCrLf + _
                            "Gwen 171" + vbCrLf
      Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
      Next
      ' List scores in descending order. 
      For Each score As KeyValuePair(Of Integer, String) In scores
         Console.WriteLine("{0}: {1}", score.Value, score.Key)
      Next
   End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
   Public Function Compare(x As T, y As T) As Integer _
          Implements IComparer(Of T).Compare
      Return Comparer(Of T).Default.Compare(x, y) * -1       
   End Function
End Class
' The example displays the following output:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());

      string input = "Joe 164\n" +  
                     "Sam 208\n" +  
                     "Allison 211\n" +  
                     "Gwen 171\n"; 
      string pattern = @"(?m)^(\w+)\s(\d+)\r*$";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
         scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);

      // List scores in descending order. 
      foreach (KeyValuePair<int, string> score in scores)
         Console.WriteLine("{0}: {1}", score.Value, score.Key);
   }
}

public class DescendingComparer<T> : IComparer<T>
{
   public int Compare(T x, T y) 
   {
      return Comparer<T>.Default.Compare(x, y) * -1;       
   }
}
// The example displays the following output:
//    Allison: 211
//    Sam: 208
//    Gwen: 171
//    Joe: 164

Retour au début

Mode sur une ligne

L'option RegexOptions.Singleline, ou l'option inline s, conduit le moteur des expressions régulières à traiter la chaîne d'entrée comme si elle ne contenait qu'une seule ligne. Il fait ceci en modifiant le comportement de l'élément de langage qu'est le point (.) afin qu'il corresponde à chaque caractère, au lieu de correspondre à chaque caractère à l'exception du caractère de saut de ligne \n ou \u000A.

L'exemple suivant illustre comment le comportement de l'élément de langage . change lorsque vous utilisez l'option RegexOptions.Singleline. L'expression régulière ^.+ démarre au début de la chaîne et correspond à tous les caractères. Par défaut, la correspondance termine à la fin de la première ligne; le modèle d'expressions régulières correspond au caractère de retour chariot, \r ou \u000D, mais il ne correspond pas à \n. Étant donné que l'option RegexOptions.Singleline interprète la chaîne d'entrée entière comme une ligne unique, il correspond à chaque caractère dans la chaîne d'entrée, notamment \n.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
      Console.WriteLine()
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//       
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

L'exemple suivant est équivalent au précédent, mais il utilise l'option inline (?s) pour activer le mode sur une seule ligne.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(?s)^.+"
      Dim input As String = "This is one line and" + vbCrLf + "this is the second."

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(Regex.Escape(match.Value))
      Next
   End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {      
      string pattern = "(?s)^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Retour au début

Captures explicites uniquement

Par défaut, les groupes de capture sont définis par l'utilisation de parenthèses dans le modèle d'expression régulière. Les groupes nommés sont assignés un nom ou compter par la (?< nom > sous-expression) option de langue, alors que les groupes sans nom sont accessibles par index. Dans l'objet GroupCollection, les groupes sans nom précèdent les groupes nommés.

Les constructions de regroupement sont souvent utilisées uniquement pour appliquer des quantificateurs à plusieurs éléments de langage, et les sous-chaînes capturées ne présentent pas d'intérêt. Par exemple, si l'expression régulière suivante :

\b\(?((\w+),?\s?)+[\.!?]\)?

sert uniquement pour extraire d'un document des phrases se terminant par un point, un point d'exclamation ou un point d'interrogation. Seule la phrase résultante (représentée par l'objet Match) nous intéresse. Les mots individuels dans la collection ne le sont pas.

Les groupes de capture qui ne sont pas utilisés par la suite peuvent être coûteux, car le moteur des expressions régulières doit remplir à la fois les objets de collection GroupCollection et CaptureCollection. Vous pouvez également utiliser soit l'option RegexOptions.ExplicitCapture, soit l'option inline n pour spécifier que les seules captures valides sont les groupes numérotés ou nommés explicitement qui sont désignés par la construction (?<nom> sous-expression).

L'exemple suivant affiche des informations sur les correspondances retournées par le modèle d'expression régulière \b\(?((\w+),?\s?)+[\.!?]\)? lorsque la méthode Match est appelée avec ou sans l'option RegexOptions.ExplicitCapture. Comme le montre la sortie du premier appel de méthode, le moteur des expressions régulières remplit complètement les objets de collection GroupCollection et CaptureCollection avec les informations relatives aux sous-chaînes capturées. Étant donné que la deuxième méthode est appelée avec options défini sur RegexOptions.ExplicitCapture, elle ne capture pas d'informations sur les groupes.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
      Console.WriteLine("With implicit captures:")
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
      Console.WriteLine()
      Console.WriteLine("With explicit captures only:")
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'    With implicit captures:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'       Group 1: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'       Group 2: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'       Group 1: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'       Group 2: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'       Group 1: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'       Group 2: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.
'       Group 1: paragraph
'          Capture 0: Instead,
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'       Group 2: paragraph
'          Capture 0: Instead
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'    
'    With explicit captures only:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
      Console.WriteLine("With implicit captures:");
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
      Console.WriteLine();
      Console.WriteLine("With explicit captures only:");
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//    With implicit captures:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//       Group 1: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//       Group 2: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//       Group 1: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//       Group 2: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//       Group 1: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//       Group 2: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
//       Group 1: paragraph
//          Capture 0: Instead,
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//       Group 2: paragraph
//          Capture 0: Instead
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//    
//    With explicit captures only:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.

Le modèle d'expression régulière \b\(?((?>\w+),?\s?)+[\.!?]\)? est défini comme indiqué dans le tableau suivant.

Modèle

Description

\b

Commencer à une limite de mot.

\(?

Mettre en correspondance zéro ou une occurrence de la parenthèse ouvrante ("(").

(?>\w+),?

Mettre en correspondance un ou plusieurs caractères alphabétiques suivis d'un zéro ou d'une virgule. Ne retournez pas en arrière lors de la mise en correspondance des caractères alphabétiques.

\s?

Mettre en correspondance zéro ou un espace blanc.

((\w+),? \s?)+

Mettre en correspondance l'association d'un ou plusieurs caractères de mot, de zéro ou d'une virgule et d'un zéro ou d'un espace blanc, une ou plusieurs fois.

[\.!?]\)?

Correspond à l'un des trois symboles de ponctuation, suivi par zéro ou une parenthèse de fermeture (")").

Vous pouvez également utiliser l'élément inclus (?n) pour supprimer les captures automatiques. L'exemple suivant modifie le modèle d'expression régulière précédent pour utiliser l'élément inline (?n) au lieu de l'option RegexOptions.ExplicitCapture.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Enfin, vous pouvez utiliser l'élément de groupe prédéfini (?n:) pour supprimer les captures automatiques groupe par groupe. L'exemple suivant modifie le modèle précédent pour supprimer les captures sans nom dans le groupe externe, ((?>\w+),?\s?) Notez que cela supprime également les captures sans nom du groupe interne.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine("The match: {0}", match.Value)
         Dim groupCtr As Integer = 0
         For Each group As Group In match.Groups
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
            groupCtr += 1
            Dim captureCtr As Integer = 0
            For Each capture As Capture In group.Captures
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
               captureCtr += 1
            Next
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine("The match: {0}", match.Value);
         int groupCtr = 0;
         foreach (Group group in match.Groups)
         {
            Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
            groupCtr++;
            int captureCtr = 0;
            foreach (Capture capture in group.Captures)
            {
               Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
               captureCtr++;
            }
         }
      }
   }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Retour au début

Expressions régulières compilées

Par défaut, les expressions régulières dans le .NET Framework sont interprétées. Lorsqu'un objet Regex est instancié ou une méthode Regex statique est appelée, le modèle d'expression régulière est analysé dans un jeu d'opcodes personnalisés, et un interpréteur utilise ces opcodes pour exécuter l'expression régulière. Cela implique un compromis : le coût de l'initialisation du moteur des expressions régulières est réduit aux dépens des performances d'exécution.

Vous pouvez utiliser des expressions régulières compilées plutôt qu'interprétées à l'aide de l'option RegexOptions.Compiled. Dans ce cas, lorsqu'un modèle est passé au moteur des expressions régulières, il est analysé dans un ensemble d'opcodes puis converti dans un langage intermédiaire Microsoft (MSIL), qui peut être passé directement au common language runtime. Les expressions régulières compilées optimisent les performances d'exécution aux dépens du temps d'initialisation.

RemarqueRemarque

Une expression régulière peut être compilée uniquement en fournissant la valeur RegexOptions.Compiled au paramètre options d'un constructeur de classe Regex ou d'une méthode statique utilisant des critères spéciaux.Il n'est pas disponible en tant qu'option inline.

Vous pouvez utiliser des expressions régulières compilées dans les appels aux expressions régulières statiques et d'instance. Dans les expressions régulières statiques, l'option RegexOptions.Compiled est passée au paramètre options de la méthode utilisant des critères spéciaux d'expression régulière. Dans les expressions régulières d'instances, elle est passée au paramètre options du constructeur de classe Regex. Dans les deux cas, les performances sont améliorées.

Toutefois, cette amélioration de performance se produit uniquement dans les cas suivants :

  • Un objet Regex qui représente une expression régulière particulière est utilisé dans plusieurs appels aux méthodes génériques utilisant des expressions régulières.

  • L'objet Regex n'est pas autorisé à sortir de la plage, il peut donc être réutilisé.

  • Une expression régulière statique est utilisée dans les appels multiples aux méthodes utilisant des critères spéciaux d'expression régulière. (L'amélioration des performances est possible parce que les expressions régulières utilisées dans les appels de méthode statique sont mises en cache par le moteur des expressions régulières.)

RemarqueRemarque

L'option RegexOptions.Compiled n'est pas liée à la méthode Regex.CompileToAssembly, qui crée un assembly à des fins déterminées qui contient des expressions régulières compilées prédéfinies.

Retour au début

Ignorer les espaces

Par défaut, l'espace blanc dans un modèle d'expression régulière est significatif ; il force le moteur des expressions régulières à établir une correspondance avec un caractère d'espace blanc dans la chaîne d'entrée. Pour cette raison , les expressions régulières "\b\w+\s" et "\b\w+ " sont sensiblement équivalentes. De plus, lorsque le signe dièse (#) est rencontré dans un modèle d'expression régulière, il est interprété comme un caractère littéral auquel correspondre.

L'option RegexOptions.IgnorePatternWhitespace, ou l'option inline x, modifie ce comportement par défaut comme suit :

  • L'espace blanc sans séquence d'échappement dans le modèle d'expression régulière est ignoré. Les caractères espace blanc doivent êtres placés dans une séquence d'échappement (par exemple, comme \s ou "\  ») pour faire partie d'un modèle d'expression régulière.

    Remarque importanteImportant

    L'espace blanc dans une classe de caractères est interprété littéralement indépendamment de l'utilisation de l'option RegexOptions.IgnorePatternWhitespace.Par exemple, le modèle d'expression régulière [ .,;:] correspond à chaque espace blanc, point, virgule, point-virgule ou deux-points.

  • Le signe dièse (#) est interprété comme début d'un commentaire, plutôt que comme un caractère littéral. Tout le texte du modèle d'expression régulière compris entre le caractère # et la fin de la chaîne est interprété comme un commentaire.

L'activation de cette option aide à simplifier des expressions régulières qui sont souvent difficiles à analyser et à comprendre. Il améliore la lisibilité et permet de documenter une expression régulière.

L'exemple suivant définit le modèle d'expression régulière suivant :

\b \(? ( (?>\w+) ,? \s? )+ [\.!?] \)? # Matches an entire sentence.

Ce modèle est semblable au modèle défini dans la section Captures explicites uniquement, mais il utilise l'option RegexOptions.IgnorePatternWhitespace pour ignorer l'espace blanc de modèle.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

L'exemple suivant utilise l'option inline (?x) pour ignorer l'espace blanc de modèle.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is the first sentence. Is it the beginning " + _
                            "of a literary masterpiece? I think not. Instead, " + _
                            "it is a nonsensical paragraph."
      Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is the first sentence. Is it the beginning " + 
                     "of a literary masterpiece? I think not. Instead, " + 
                     "it is a nonsensical paragraph.";
      string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence.";

      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Retour au début

Mode de droite à gauche

Par défaut, le moteur des expressions régulières effectue les recherches de gauche à droite. Vous pouvez inverser le sens de la recherche à l'aide de l'option RegexOptions.RightToLeft. La recherche commence automatiquement à la dernière position de caractère de la chaîne. Pour les méthodes utilisant des critères spéciaux qui incluent un paramètre de position de départ, tel que Regex.Match(String, Int32), la position de départ est l'index de la position du caractère le plus à droite à laquelle la recherche doit commencer.

RemarqueRemarque

Le mode de droite à gauche est uniquement disponible en fournissant la valeur RegexOptions.RightToLeft au paramètre options d'un constructeur de classe Regex ou une méthode statique utilisant des critères spéciaux.Il n'est pas disponible en tant qu'option inline.

L'option RegexOptions.RightToLeft modifie le sens de la recherche uniquement ; il n'interprète pas le modèle d'expression régulière de droite à gauche. Par exemple, l'expression régulière \bb\w+\s correspond aux mots qui commencent par la lettre « b » et sont suivis par un espace blanc. Dans l'exemple suivant, la chaîne d'entrée se compose de trois mots qui incluent un ou plusieurs « b ». Le premier mot commence par « b », le deuxième se termine par « b », et le troisième inclut deux caractères « b » au le milieu du mot. Comme le montre la sortie de l'exemple, seul le premier mot correspond au modèle d'expression régulière.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bb\w+\s"
      Dim input As String = "builder rob rabble"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)     
      Next
   End Sub
End Module
' The example displays the following output:
'       'builder ' found at position 0.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bb\w+\s";
      string input = "builder rob rabble";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
         Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);     
   }
}
// The example displays the following output:
//       'builder ' found at position 0.

Notez également que l'assertion de préanalyse (élément de langage de la (?=sous-expression)) et l'assertion de postanalyse (élément de langage de la (?<=sous-expression)) ne modifient pas la direction. Les assertions en avant regardent à droite ; les assertions en arrière regardent à gauche. Par exemple, l'expression régulière (?<=\d{1,2}\s)\w+,*\s\d{4} utilise l'assertion lookbehind pour tester une date qui précède un nom de mois. L'expression régulière met ensuite en correspondance le mois et l'année. Pour plus d'informations sur les assertions lookahead et lookbehind, consultez Constructions de regroupement.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "1 May 1917", "June 16, 2003" }
      Dim pattern As String = "(?<=\d{1,2}\s)\w+,?\s\d{4}"

      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
         If match.Success Then
            Console.WriteLine("The date occurs in {0}.", match.Value)
         Else
            Console.WriteLine("{0} does not match.", input)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       The date occurs in May 1917.
'       June 16, 2003 does not match.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "1 May 1917", "June 16, 2003" };
      string pattern = @"(?<=\d{1,2}\s)\w+,?\s\d{4}";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
         if (match.Success)
            Console.WriteLine("The date occurs in {0}.", match.Value);
         else
            Console.WriteLine("{0} does not match.", input);
      }
   }
}
// The example displays the following output:
//       The date occurs in May 1917.
//       June 16, 2003 does not match.

Le modèle d'expression régulière est défini comme indiqué dans le tableau suivant.

Modèle

Description

(?<=\d{1,2}\s)

Le début de la correspondance doit être précédé par un ou deux chiffres décimaux suivis par un espace.

\w+

Mettre en correspondance un ou plusieurs caractères alphabétiques.

,*

Correspond à zéro ou à une virgule.

\s

Mettre en correspondance un espace blanc.

\d{4}

Mettre en correspondance quatre chiffres décimaux.

Retour au début

Comportement correspondant à ECMAScript

Par défaut, le moteur des expressions régulières utilise le comportement canonique lorsqu'il fait correspondre un modèle d'expression régulière avec un texte d'entrée. Toutefois, vous pouvez indiquer au moteur des expressions régulières d'utiliser le comportement correspondant à ECMAScript en spécifiant l'option RegexOptions.ECMAScript.

RemarqueRemarque

Le comportement compatible ECMAScript est uniquement disponible en fournissant la valeur RegexOptions.ECMAScript au paramètre options d'un constructeur de classe Regex ou d'une méthode statique utilisant des critères spéciaux.Il n'est pas disponible en tant qu'option inline.

L'option RegexOptions.ECMAScript peut également être associée aux options RegexOptions.IgnoreCase et RegexOptions.Multiline. L'utilisation de toute autre option dans une expression régulière provoque un ArgumentOutOfRangeException.

Le comportement d'ECMAScript et des expressions régulières canoniques diffère dans trois domaines : syntaxe de classe de caractères, groupes de capture avec référence circulaire et interprétation octale versus référence arrière.

  • Syntaxe de classe de caractères. Étant donné que les expressions régulières canoniques prennent en charge Unicode alors qu'ECMAScript ne le fait pas, les classes de caractères dans ECMAScript ont une syntaxe plus limitée, et certains éléments de langage de classe de caractères ont une signification différente. Par exemple, ECMAScript ne prend pas en charge les éléments de langage tels que la catégorie Unicode ou les éléments de bloc \p et \P. De la même façon, l'élément \w, qui correspond à un caractère alphabétique, est équivalent à la classe de caractères [a-zA-Z_0-9] lors de l'utilisation d'ECMAScript et [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] lors de l'utilisation du comportement canonique. Pour plus d'informations, consultez Classes de caractères.

    L'exemple suivant illustre la différence les critères spéciaux canoniques et ECMAScript. Il définit une expression régulière, \b(\w+\s*)+, qui correspond aux mots suivis par des espaces de blanc. L'entrée se compose de deux chaînes, une qui utilise le jeu de caractères latin et l'autre qui utilise le jeu de caractères cyrillique. Comme le montre la sortie, l'appel à la méthode Regex.IsMatch(String, String, RegexOptions) qui utilise la correspondance ECMAScript ne parvient pas à faire correspondre les mots en cyrillique, alors que l'appel de méthode qui utilise la correspondance canonique y parvient.

    Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim values() As String = { "целый мир", "the whole world" }
      Dim pattern As String = "\b(\w+\s*)+"
      For Each value In values
         Console.Write("Canonical matching: ")
         If Regex.IsMatch(value, pattern)
            Console.WriteLine("'{0}' matches the pattern.", value)
         Else
            Console.WriteLine("{0} does not match the pattern.", value)
         End If

         Console.Write("ECMAScript matching: ")
         If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript)
            Console.WriteLine("'{0}' matches the pattern.", value)
         Else
            Console.WriteLine("{0} does not match the pattern.", value)
         End If
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       Canonical matching: 'целый мир' matches the pattern.
'       ECMAScript matching: целый мир does not match the pattern.
'       
'       Canonical matching: 'the whole world' matches the pattern.
'       ECMAScript matching: 'the whole world' matches the pattern.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] values = { "целый мир", "the whole world" };
      string pattern = @"\b(\w+\s*)+";
      foreach (var value in values)
      {
         Console.Write("Canonical matching: ");
         if (Regex.IsMatch(value, pattern))
            Console.WriteLine("'{0}' matches the pattern.", value);
         else
            Console.WriteLine("{0} does not match the pattern.", value);

         Console.Write("ECMAScript matching: ");
         if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
            Console.WriteLine("'{0}' matches the pattern.", value);
         else
            Console.WriteLine("{0} does not match the pattern.", value);
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Canonical matching: 'целый мир' matches the pattern.
//       ECMAScript matching: целый мир does not match the pattern.
//       
//       Canonical matching: 'the whole world' matches the pattern.
//       ECMAScript matching: 'the whole world' matches the pattern.

  • Référence circulaire de groupes de capture. Une classe de captures d'expressions régulières avec une backreference vers elle-même doit être mise à jour à chaque itération de capture. Comme le montre l'exemple suivant, cette fonctionnalité permet à l'expression régulière ((a+)(\1) ?)+ de correspondre à la chaîne d'entrée " aa aaaa aaaaaa " lors de l'utilisation d'ECMAScript, mais pas lors de l'utilisation de la correspondance canonique.

    L'expression régulière est définie comme indiqué dans le tableau suivant.

    Modèle

    Description

    A

    Correspond à la lettre « a » une ou plusieurs fois. Il s'agit du deuxième groupe de capture.

    (\1)

    Correspond à la sous-chaîne capturée par le premier groupe de capture. Il s'agit du troisième groupe de capture.

    ?

    Mettre en correspondance zéro ou un espace blanc.

    ((a+)(\1) ?)+

    Correspond au modèle d'un ou plusieurs caractères « a » suivis par une chaîne qui correspond au premier groupe de capture suivi par zéro ou un ou plusieurs espaces. Il s'agit du premier groupe de capture.

  • Résolution d'ambiguïtés entre échappements octaux et backreferences. Le tableau suivant récapitule les différences d'interprétation octale et backreference par les expressions régulières canoniques et ECMAScript.

    Expression régulière

    Comportement canonique

    Comportement ECMAScript

    \0 suivi par 0 à 2 chiffres octaux

    Interprétez comme un octal. Par exemple, \044 est toujours interprété comme une valeur octale et signifie « $ ».

    Comportement identique.

    \ suivi par un chiffre de 1 à 9, suivis par aucun chiffre décimal supplémentaire

    Interprétez comme une backreference. Par exemple, \9 signifie toujours backreference 9, même s'il n'existe pas de neuvième groupe de captures. Si le groupe de capture n'existe pas, l'analyseur d'expression régulière lève une exception ArgumentException.

    S'il existe un groupe de capture de chiffre décimal unique, backreference à ce chiffre. Sinon, interprétez la valeur comme un littéral.

    \ suivi par un chiffre de 1 à 9, suivis par des chiffres décimaux supplémentaires

    Interprétez les chiffres comme une valeur décimale. Si ce groupe de capture existe, interprétez l'expression comme une backreference.

    Sinon, interprétez les chiffres octaux principaux jusqu'à l'octal 377 ; autrement dit, considérez uniquement les 8 bits inférieurs de la valeur. Interprétez les chiffres restants comme littéraux. Par exemple, dans l'expression \3000, si le groupe de capture 300 existe, interprétez comme une backreference 300 ; si le groupe de capture 300 n'existe pas, interprétez comme un octal 300 suivi de 0.

    Interprétez comme une backreference en convertissant autant de chiffres que possible en une valeur décimale qui peut faire référence à une capture. Si aucun chiffre ne peut être converti, interprétez comme un octal en utilisant les chiffres octaux principaux jusqu'au 377 ; interprétez les chiffres restants comme des littéraux.

Retour au début

Comparaison à l'aide de la culture dite indifférente

Par défaut, lorsque le moteur des expressions régulières exécute des comparaisons qui ne respectent pas la casse, il utilise les conventions de casse de la culture actuelle pour déterminer les caractères majuscules et minuscules équivalents.

Toutefois, ce comportement est indésirable pour certaines types de comparaisons, en particulier lors de la comparaison d'une entrée d'utilisateur avec les noms des ressources système, telles que les mots de passe, les fichiers ou les URL. L'exemple suivant illustre ce type de scénario. Le code vise à bloquer l'accès à toute ressource dont l'URL est préfacée de FILE://. L'expression régulière tente une mise en correspondance non sensible à la casse avec la chaîne à l'aide de l'expression régulière $FILE://. Toutefois, lorsque la culture actuelle du système a la valeur tr-TR (Turc -Turquie), « I » n'est pas l'équivalent majuscule de « i ». Par conséquent, l'appel à la méthode Regex.IsMatch retourne la valeur false, et l'accès au fichier est autorisé.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-sensitive matching ({0} culture)...", _
                  Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If

Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'       Culture-sensitive matching (tr-TR culture)...
'       Access to file://c:/Documents.MyReport.doc is allowed.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-sensitive matching ({0} culture)...", 
                  Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
   Console.WriteLine("URLs that access files are not allowed.");      
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-sensitive matching (tr-TR culture)...
//       Access to file://c:/Documents.MyReport.doc is allowed.
RemarqueRemarque

   Pour plus d'informations sur les comparaisons de chaînes qui respectent la casse et utilisent la culture dite indifférente, consultez Meilleures pratiques pour l'utilisation de chaînes dans le .NET Framework.

Au lieu d'utiliser des comparaisons ne respectant pas la casse de la culture actuelle, vous pouvez spécifier l'option RegexOptions.CultureInvariant pour ignorer les différences culturelles de la langue et utiliser les conventions de culture indifférente.

RemarqueRemarque

La comparaison à l'aide de la culture dite indifférente est uniquement disponible en fournissant la valeur RegexOptions.CultureInvariant au paramètre options d'un constructeur de classe Regex ou d'une méthode statique utilisant des critères spéciaux.Il n'est pas disponible en tant qu'option inline.

L'exemple suivant est identique au précédent, mais la méthode Regex.IsMatch(String, String, RegexOptions) statique est appelée avec des options qui incluent RegexOptions.CultureInvariant. Même lorsque la culture actuelle est définie sur lle Turc (Turquie), le moteur des expressions régulières est en mesure de faire correspondre « FICHIER » et « fichier » et de bloquer l'accès à la ressource du fichier.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern, _
               RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
   Console.WriteLine("URLs that access files are not allowed.")      
Else
   Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'        Culture-insensitive matching...
'        URLs that access files are not allowed.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern, 
                  RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)) 
   Console.WriteLine("URLs that access files are not allowed.");
else
   Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-insensitive matching...
//       URLs that access files are not allowed.

Retour au début

Voir aussi

Concepts

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