Classes de caractères dans les expressions régulièresCharacter classes in regular expressions

Une classe de caractères définit un jeu de caractères, chacun d'entre eux pouvant apparaître dans une chaîne d'entrée pour aboutir à une correspondance.A character class defines a set of characters, any one of which can occur in an input string for a match to succeed. Le langage d’expression régulière dans .NET prend en charge les classes de caractères suivantes :The regular expression language in .NET supports the following character classes:

  • Groupes de caractères positifs.Positive character groups. Un caractère de la chaîne d'entrée doit correspondre à l'un des jeux de caractères spécifié.A character in the input string must match one of a specified set of characters. Pour plus d’informations, consultez Groupe de caractères positif.For more information, see Positive Character Group.

  • Groupes de caractères négatifs.Negative character groups. Un caractère de la chaîne d'entrée ne doit pas correspondre à l'un des jeux de caractères spécifié.A character in the input string must not match one of a specified set of characters. Pour plus d’informations, consultez Groupe de caractères négatif.For more information, see Negative Character Group.

  • N'importe quel caractère.Any character. Le caractère . (point) dans une expression régulière est un caractère générique qui correspond à n'importe quel caractère sauf \n.The . (dot or period) character in a regular expression is a wildcard character that matches any character except \n. Pour plus d’informations, consultez N’importe quel caractère.For more information, see Any Character.

  • Catégorie Unicode générale ou bloc nommé.A general Unicode category or named block. Un caractère de la chaîne d'entrée doit être membre d'une catégorie Unicode particulière ou doit figurer dans une plage contiguë de caractères Unicode pour aboutir à une correspondance.A character in the input string must be a member of a particular Unicode category or must fall within a contiguous range of Unicode characters for a match to succeed. Pour plus d’informations, consultez Catégorie Unicode ou bloc Unicode.For more information, see Unicode Category or Unicode Block.

  • Catégorie Unicode générale négative ou bloc nommé.A negative general Unicode category or named block. Un caractère de la chaîne d'entrée ne doit pas être membre d'une catégorie Unicode particulière ou ne doit pas figurer dans une plage contiguë de caractères Unicode pour aboutir à une correspondance.A character in the input string must not be a member of a particular Unicode category or must not fall within a contiguous range of Unicode characters for a match to succeed. Pour plus d’informations, consultez Catégorie ou bloc Unicode négatifs.For more information, see Negative Unicode Category or Unicode Block.

  • Caractère de mot.A word character. Un caractère de la chaîne d'entrée peut appartenir à l'une des catégories Unicode appropriées aux caractères contenus dans les mots.A character in the input string can belong to any of the Unicode categories that are appropriate for characters in words. Pour plus d’informations, consultez Caractère de mot.For more information, see Word Character.

  • Caractère autre qu'un caractère de mot.A non-word character. Un caractère de la chaîne d'entrée peut appartenir à n'importe quelle catégorie Unicode qui n'est pas un caractère de mot.A character in the input string can belong to any Unicode category that is not a word character. Pour plus d’informations, consultez Caractère autre qu’un caractère de mot.For more information, see Non-Word Character.

  • Espace blanc.A white-space character. Un caractère de la chaîne d'entrée peut être n'importe quel caractère Unicode de séparation, ainsi que n'importe quel nombre de caractères de contrôle.A character in the input string can be any Unicode separator character, as well as any one of a number of control characters. Pour plus d’informations, consultez Espace blanc.For more information, see White-Space Character.

  • Caractère autre qu'un espace blanc.A non-white-space character. Un caractère de la chaîne d'entrée peut être n'importe quel caractère qui n'est pas un espace blanc.A character in the input string can be any character that is not a white-space character. Pour plus d’informations, consultez Caractère autre qu’un espace blanc.For more information, see Non-White-Space Character.

  • Chiffre décimal.A decimal digit. Un caractère de la chaîne d'entrée peut être n'importe quel nombre de caractères classifiés en tant que chiffres décimaux Unicode.A character in the input string can be any of a number of characters classified as Unicode decimal digits. Pour plus d’informations, consultez Chiffre décimal.For more information, see Decimal Digit Character.

  • Chiffre non décimal.A non-decimal digit. Un caractère de la chaîne d'entrée peut correspondre à autre chose qu'un chiffre décimal Unicode.A character in the input string can be anything other than a Unicode decimal digit. Pour plus d’informations, consultez Chiffre décimal.For more information, see Decimal Digit Character.

.NET prend en charge les expressions de soustraction de classe de caractères, ce qui vous permet de définir un jeu de caractères comme résultat de l’exclusion d’une classe de caractères d’une autre classe de caractères..NET supports character class subtraction expressions, which enables you to define a set of characters as the result of excluding one character class from another character class. Pour plus d’informations, consultez Soustraction de classe de caractères.For more information, see Character Class Subtraction.

Notes

Les classes de caractères qui font correspondre les caractères par catégorie, comme \w pour faire correspondre les caractères alphabétiques, ou \p{} pour les faire correspondre à une catégorie Unicode, s’appuient sur la classe CharUnicodeInfo pour fournir des informations sur les catégories de caractères.Character classes that match characters by category, such as \w to match word characters or \p{} to match a Unicode category, rely on the CharUnicodeInfo class to provide information about character categories. À compter de .NET Framework 4.6.2, les catégories de caractères sont basées sur la norme Unicode version 8.0.0.Starting with the .NET Framework 4.6.2, character categories are based on The Unicode Standard, Version 8.0.0. De .NET Framework 4 à .NET Framework 4.6.1, elles sont basées sur la norme Unicode version 6.3.0.In the .NET Framework 4 through the .NET Framework 4.6.1, they are based on The Unicode Standard, Version 6.3.0.

Groupe de caractères positif : [ ]Positive character group: [ ]

Un groupe de caractères positif spécifie une liste de caractères, chacun d'entre eux pouvant apparaître dans une chaîne d'entrée pour produire une correspondance.A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. Cette liste de caractères peut être spécifiée individuellement, comme une plage, ou les deux à la fois.This list of characters may be specified individually, as a range, or both.

La syntaxe de la spécification d'une liste de différents caractères est comme suit :The syntax for specifying a list of individual characters is as follows:

[*character_group*]  

groupe_caractères est la liste des différents caractères pouvant apparaître dans la chaîne d’entrée pour qu’une correspondance soit établie.where character_group is a list of the individual characters that can appear in the input string for a match to succeed. groupe_caractères peut être constitué de n’importe quelle combinaison d’un ou de plusieurs caractères littéraux, de caractères d’échappement ou de classes de caractères.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

La syntaxe de la spécification d'une plage de caractères est comme suit :The syntax for specifying a range of characters is as follows:

[firstCharacter-lastCharacter]  

premierCaractère est le caractère qui commence la plage et dernierCaractère est celui qui la termine.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Une plage de caractères est une série contiguë de caractères définie par la spécification du premier caractère de la série, d'un trait d'union (-), puis du dernier caractère de la série.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Deux caractères sont contigus s'ils présentent des points de code Unicode adjacents.Two characters are contiguous if they have adjacent Unicode code points. premierCaractère doit être le caractère avec le code de caractère le plus faible et dernierCaractère doit être le caractère avec le code de caractère le plus élevé.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

Notes

Étant donné qu’un groupe de caractères positif peut inclure à la fois un jeu de caractères et une plage de caractères, un trait d’union (-) est toujours interprété comme le séparateur de plage, sauf s’il s’agit du premier ou dernier caractère du groupe.Because a positive character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

Quelques modèles d'expressions régulières courants qui contiennent des classes de caractères positifs apparaissent dans le tableau suivant.Some common regular expression patterns that contain positive character classes are listed in the following table.

MotifPattern DescriptionDescription
[aeiou] Mettre en correspondance toutes les voyelles.Match all vowels.
[\p{P}\d] Mettre en correspondance tous les signes de ponctuation et chiffres décimaux.Match all punctuation and decimal digit characters.
[\s\p{P}] Mettre en correspondance tous les espaces blancs et signes de ponctuation.Match all white space and punctuation.

L'exemple suivant définit un groupe de caractères positif qui contient les caractères « a » et « e » afin que la chaîne d'entrée contienne les mots « grey » ou « gray » suivis par un autre mot pour produire une correspondance.The following example defines a positive character group that contains the characters "a" and "e" so that the input string must contain the words "grey" or "gray" followed by another word for a match to occur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
      Dim input As String = "The gray wolf jumped over the grey wall."
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      For Each match As Match In matches
         Console.WriteLine($"'{match.Value}'")
      Next
   End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

L'expression régulière gr[ae]y\s\S+?[\s|\p{P}] est définie comme suit :The regular expression gr[ae]y\s\S+?[\s|\p{P}] is defined as follows:

MotifPattern DescriptionDescription
gr Mettre en correspondance les caractères littéraux « gr ».Match the literal characters "gr".
[ae] Mettre en correspondance un « a » ou un « e ».Match either an "a" or an "e".
y\s Mettre en correspondance le caractère littéral « y » suivi d'un espace blanc.Match the literal character "y" followed by a white-space character.
\S+? Mettre en correspondance un ou plusieurs caractères autres que des espaces blancs, mais le moins possible.Match one or more non-white-space characters, but as few as possible.
[\s\p{P}] Mettre en correspondance un espace blanc ou un signe de ponctuation.Match either a white-space character or a punctuation mark.

L'exemple suivant correspond aux mots qui commencent par une majuscule.The following example matches words that begin with any capital letter. Il utilise la sous-expression [A-Z] pour représenter la plage de majuscules de A à Z.It uses the subexpression [A-Z] to represent the range of capital letters from A to Z.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[A-Z]\w*\b"
      Dim input As String = "A city Albany Zulu maritime Marseilles"
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module

L'expression régulière \b[A-Z]\w*\b est définie comme indiqué dans le tableau suivant.The regular expression \b[A-Z]\w*\b is defined as shown in the following table.

MotifPattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
[A-Z] Mettre en correspondance une majuscule de A à Z.Match any uppercase character from A to Z.
\w* Mettre en correspondance zéro, un ou plusieurs caractères alphabétiques.Match zero or more word characters.
\b Mettre en correspondance la limite d'un mot.Match a word boundary.

Groupe de caractères négatif : [^]Negative character group: [^]

Un groupe de caractères négatifs spécifie une liste de caractères qui ne doivent pas s'afficher dans une chaîne d'entrée pour produire une correspondance.A negative character group specifies a list of characters that must not appear in an input string for a match to occur. La liste de caractères peut être spécifiée individuellement, comme une plage, ou les deux à la fois.The list of characters may be specified individually, as a range, or both.

La syntaxe de la spécification d'une liste de différents caractères est comme suit :The syntax for specifying a list of individual characters is as follows:

[*^character_group*]  

groupe_caractères est la liste des différents caractères qui ne peuvent pas apparaître dans la chaîne d’entrée pour qu’une correspondance soit établie.where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. groupe_caractères peut être constitué de n’importe quelle combinaison d’un ou de plusieurs caractères littéraux, de caractères d’échappement ou de classes de caractères.character_group can consist of any combination of one or more literal characters, escape characters, or character classes.

La syntaxe de la spécification d'une plage de caractères est comme suit :The syntax for specifying a range of characters is as follows:

[^*firstCharacter*-*lastCharacter*]  

premierCaractère est le caractère qui commence la plage et dernierCaractère est celui qui la termine.where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. Une plage de caractères est une série contiguë de caractères définie par la spécification du premier caractère de la série, d'un trait d'union (-), puis du dernier caractère de la série.A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Deux caractères sont contigus s'ils présentent des points de code Unicode adjacents.Two characters are contiguous if they have adjacent Unicode code points. premierCaractère doit être le caractère avec le code de caractère le plus faible et dernierCaractère doit être le caractère avec le code de caractère le plus élevé.firstCharacter must be the character with the lower code point, and lastCharacter must be the character with the higher code point.

Notes

Étant donné qu’un groupe de caractères négatif peut inclure à la fois un jeu de caractères et une plage de caractères, un trait d’union (-) est toujours interprété comme le séparateur de plage, sauf s’il s’agit du premier ou dernier caractère du groupe.Because a negative character group can include both a set of characters and a character range, a hyphen character (-) is always interpreted as the range separator unless it is the first or last character of the group.

Deux ou plusieurs plages de caractères peuvent être concaténées.Two or more character ranges can be concatenated. Par exemple, pour spécifier la plage de chiffres décimaux de « 0 » à « 9 », la plage de lettres minuscules de « a » à « f » et la plage de lettres majuscules de « A » à « F », utilisez [0-9a-fA-F].For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].

Le premier caractère (^) d'un groupe de caractères négatif est obligatoire et indique que le groupe de caractères est un groupe de caractères négatif et non positif.The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.

Important

Un groupe de caractères négatifs d'un plus grand modèle d'expressions régulières n'est pas une assertion de largeur nulle.A negative character group in a larger regular expression pattern is not a zero-width assertion. Autrement dit, après avoir évalué le groupe de caractères négatif, le moteur des expressions régulières avance d'un caractère dans la chaîne d'entrée.That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.

Quelques modèles d'expressions régulières courants qui contiennent des groupes de caractères négatifs apparaissent dans le tableau suivant.Some common regular expression patterns that contain negative character groups are listed in the following table.

MotifPattern DescriptionDescription
[^aeiou] Mettre en correspondance tous les caractères, à l'exception des voyelles.Match all characters except vowels.
[^\p{P}\d] Mettre en correspondance tous les caractères, à l'exception des signes de ponctuation et des chiffres décimaux.Match all characters except punctuation and decimal digit characters.

L'exemple suivant correspond à un mot commençant par les caractères « th » et n'étant pas suivi d'un « o ».The following example matches any word that begins with the characters "th" and is not followed by an "o".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\bth[^o]\w+\b"
      Dim input As String = "thought thing though them through thus " + _
                            "thorough this"
      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:
'       thing
'       them
'       through
'       thus
'       this

L'expression régulière \bth[^o]\w+\b est définie comme indiqué dans le tableau suivant.The regular expression \bth[^o]\w+\b is defined as shown in the following table.

MotifPattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
th Mettre en correspondance les caractères littéraux « th ».Match the literal characters "th".
[^o] Mettre en correspondance n'importe quel caractère autre que « o ».Match any character that is not an "o".
\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.Match one or more word characters.
\b Terminer à une limite de mot.End at a word boundary.

N’importe quel caractère : .Any character: .

Le point (.) correspond à n'importe quel caractère à l'exception de \n (caractère de saut de ligne, \u000A), avec les deux qualifications suivantes :The period character (.) matches any character except \n (the newline character, \u000A), with the following two qualifications:

  • Si un modèle d'expression régulière est modifié par l'option RegexOptions.Singleline ou si la partie du modèle qui contient la classe de caractères . est modifiée par l'option s, . correspond à n'importe quel caractère.If a regular expression pattern is modified by the RegexOptions.Singleline option, or if the portion of the pattern that contains the . character class is modified by the s option, . matches any character. Pour plus d’informations, consultez Options des expressions régulières.For more information, see Regular Expression Options.

    L'exemple suivant illustre le comportement différent de la classe de caractères . par défaut et avec l'option RegexOptions.Singleline.The following example illustrates the different behavior of the . character class by default and with the RegexOptions.Singleline option. L'expression régulière ^.+ commence au début de la chaîne et correspond à tous les caractères.The regular expression ^.+ starts at the beginning of the string and matches every character. Par défaut, la correspondance se termine à la fin de la première ligne ; le modèle d'expression régulière correspond au retour chariot, à \r ou à \u000D, mais il ne correspond pas à \n.By default, the match ends at the end of the first line; the regular expression pattern matches the carriage return character, \r or \u000D, but it does not match \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 de la chaîne d'entrée, notamment \n.Because the RegexOptions.Singleline option interprets the entire input string as a single line, it matches every character in the input string, including \n.

    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\.
    
    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\.
    

Notes

Étant donné qu'elle correspond à n'importe quel caractère sauf \n, la classe de caractères . correspond également à \r (retour chariot, \u000D).Because it matches any character except \n, the . character class also matches \r (the carriage return character, \u000D).

  • Dans un groupe de caractères négatif ou positif, un point est traité comme un caractère littéral de point, et non pas comme une classe de caractères.In a positive or negative character group, a period is treated as a literal period character, and not as a character class. Pour plus d'informations, consultez Groupe de caractères positif et Groupe de caractères négatif plus haut dans cette rubrique.For more information, see Positive Character Group and Negative Character Group earlier in this topic. L'exemple suivant en propose une illustration. Il définit une expression régulière qui inclut le point (.) à la fois en tant que classe de caractères et en tant que membre d'un groupe de caractères positif.The following example provides an illustration by defining a regular expression that includes the period character (.) both as a character class and as a member of a positive character group. L’expression régulière \b.*[.?!;:](\s|\z) commence à une limite de mot, correspond à n’importe quel caractère tant qu’elle ne rencontre pas l’un des cinq signes de ponctuation, y compris le point, puis correspond à un espace blanc ou à la fin de la chaîne.The regular expression \b.*[.?!;:](\s|\z) begins at a word boundary, matches any character until it encounters one of five punctuation marks, including a period, and then matches either a white-space character or the end of the string.

    using System;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          string pattern = @"\b.*[.?!;:](\s|\z)";
          string input = "this. what: is? go, thing.";
          foreach (Match match in Regex.Matches(input, pattern))
             Console.WriteLine(match.Value);
       }
    }
    // The example displays the following output:
    //       this. what: is? go, thing.
    
    Imports System.Text.RegularExpressions
    
    Module Example
       Public Sub Main()
          Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
          Dim input As String = "this. what: is? go, thing."
          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. what: is? go, thing.
    

Notes

Étant donné qu'il correspond à n'importe quel caractère, l'élément de langage . est souvent utilisé avec un quantificateur limitatif si un modèle d'expression régulière essaie de correspondre plusieurs fois à n'importe quel caractère.Because it matches any character, the . language element is often used with a lazy quantifier if a regular expression pattern attempts to match any character multiple times. Pour plus d’informations, consultez Quantificateurs.For more information, see Quantifiers.

Catégorie Unicode ou bloc Unicode : \p{}Unicode category or Unicode block: \p{}

La norme Unicode assigne une catégorie générale à chaque caractère.The Unicode standard assigns each character a general category. Par exemple, un caractère particulier peut être une lettre majuscule (représenté par la catégorie Lu), un chiffre décimal (catégorie Nd), un symbole mathématique (catégorie Sm) ou un séparateur de paragraphe (catégorie Zl).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Les jeux de caractères spécifiques de la norme Unicode occupent également une plage spécifique ou un bloc de points de code consécutifs.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Par exemple, l'alphabet latin de base se trouve de \u0000 à \u007F, alors que le jeu de caractères arabe se trouve de \u0600 à \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

La construction d'expression régulièreThe regular expression construct

\p{ name }\p{ name }

correspond à n’importe quel caractère qui appartient à une catégorie Unicode générale ou à un bloc nommé, où nom est l’abréviation de la catégorie ou le nom du bloc nommé.matches any character that belongs to a Unicode general category or named block, where name is the category abbreviation or named block name. Pour obtenir la liste des abréviations des catégories, consultez la section Catégories générales Unicode prises en charge plus loin dans cette rubrique.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Pour obtenir la liste des blocs nommés, consultez la section Blocs nommés pris en charge plus loin dans cette rubrique.For a list of named blocks, see the Supported Named Blocks section later in this topic.

L’exemple suivant utilise la construction \p{nom} pour mettre en correspondance une catégorie Unicode générale (dans ce cas, la catégorie Pd ou Punctuation, Dash) et un bloc nommé (les blocs nommés IsGreek et IsBasicLatin).The following example uses the \p{name} construct to match both a Unicode general category (in this case, the Pd, or Punctuation, Dash category) and a named block (the IsGreek and IsBasicLatin named blocks).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
      Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

      Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
   End Sub
End Module

L'expression régulière \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ est définie comme indiqué dans le tableau suivant.The regular expression \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ is defined as shown in the following table.

MotifPattern DescriptionDescription
\b Commencer à la limite d'un mot.Start at a word boundary.
\p{IsGreek}+ Mettre en correspondance un ou plusieurs caractères grecs.Match one or more Greek characters.
(\s)? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
(\p{IsGreek}+(\s)?)+ Mettre en correspondance le modèle d’un ou plusieurs caractères grecs, suivis de zéro ou d’un espace blanc, une ou plusieurs fois.Match the pattern of one or more Greek characters followed by zero or one white-space characters one or more times.
\p{Pd} Mettre en correspondance un signe de ponctuation tiret.Match a Punctuation, Dash character.
\s Mettre en correspondance un espace blanc.Match a white-space character.
\p{IsBasicLatin}+ Mettre en correspondance un ou plusieurs caractères latins de base.Match one or more basic Latin characters.
(\s)? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
(\p{IsBasicLatin}+(\s)?)+ Mettre en correspondance un ou plusieurs caractères latins de base suivis de zéro ou d’un espace blanc, une ou plusieurs fois.Match the pattern of one or more basic Latin characters followed by zero or one white-space characters one or more times.

Catégorie Unicode négative ou bloc Unicode : \P{}Negative Unicode category or Unicode block: \P{}

La norme Unicode assigne une catégorie générale à chaque caractère.The Unicode standard assigns each character a general category. Par exemple, un caractère particulier peut être une lettre majuscule (représenté par la catégorie Lu), un chiffre décimal (catégorie Nd), un symbole mathématique (catégorie Sm) ou un séparateur de paragraphe (catégorie Zl).For example, a particular character can be an uppercase letter (represented by the Lu category), a decimal digit (the Nd category), a math symbol (the Sm category), or a paragraph separator (the Zl category). Les jeux de caractères spécifiques de la norme Unicode occupent également une plage spécifique ou un bloc de points de code consécutifs.Specific character sets in the Unicode standard also occupy a specific range or block of consecutive code points. Par exemple, l'alphabet latin de base se trouve de \u0000 à \u007F, alors que le jeu de caractères arabe se trouve de \u0600 à \u06FF.For example, the basic Latin character set is found from \u0000 through \u007F, while the Arabic character set is found from \u0600 through \u06FF.

La construction d'expression régulièreThe regular expression construct

\P{ name }\P{ name }

correspond à n'importe quel caractère qui n'appartient pas à une catégorie générale Unicode ou à un bloc nommé, où nom est l'abréviation de la catégorie ou le nom du bloc nommé.matches any character that does not belong to a Unicode general category or named block, where name is the category abbreviation or named block name. Pour obtenir la liste des abréviations des catégories, consultez la section Catégories générales Unicode prises en charge plus loin dans cette rubrique.For a list of category abbreviations, see the Supported Unicode General Categories section later in this topic. Pour obtenir la liste des blocs nommés, consultez la section Blocs nommés pris en charge plus loin dans cette rubrique.For a list of named blocks, see the Supported Named Blocks section later in this topic.

L'exemple suivant utilise la construction \P{nom} pour supprimer tous les symboles monétaires (dans ce cas, la catégorie Sc ou Symbol, Currency) des chaînes numériques.The following example uses the \P{name} construct to remove any currency symbols (in this case, the Sc, or Symbol, Currency category) from numeric strings.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";
      
      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\P{Sc})+"
      
      Dim values() As String = { "$164,091.78", "£1,073,142.68", "73¢", "€120"}
      For Each value As String In values
         Console.WriteLine(Regex.Match(value, pattern).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

Le modèle d'expression régulière (\P{Sc})+ correspond à un ou plusieurs caractères qui ne sont pas des symboles monétaires ; il supprime efficacement tout symbole monétaire de la chaîne du résultat.The regular expression pattern (\P{Sc})+ matches one or more characters that are not currency symbols; it effectively strips any currency symbol from the result string.

Caractère de mot : \wWord character: \w

\w correspond à n'importe quel caractère alphabétique.\w matches any word character. Un caractère de mot est un membre d'une des catégories Unicode répertoriées dans le tableau suivant.A word character is a member of any of the Unicode categories listed in the following table.

CategoryCategory DescriptionDescription
LlLl Letter, LowercaseLetter, Lowercase
LuLu Letter, UppercaseLetter, Uppercase
LtLt Letter, TitlecaseLetter, Titlecase
LoLo Letter, OtherLetter, Other
LmLm Letter, ModifierLetter, Modifier
MnMn Mark, NonspacingMark, Nonspacing
NdNd Number, Decimal DigitNumber, Decimal Digit
PcPc Punctuation, Connector.Punctuation, Connector. Cette catégorie inclut dix caractères dont le plus souvent utilisé est le caractère LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Si un comportement conforme à ECMAScript est spécifié, \w est équivalent à [a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \w is equivalent to [a-zA-Z_0-9]. Pour plus d’informations sur les expressions régulières ECMAScript, consultez la section « Comportement de correspondance ECMAScript » dans Options des expressions régulières.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Notes

Étant donné qu'il correspond à n'importe quel caractère alphabétique, l'élément de langage \w est souvent utilisé avec un quantificateur limitatif si un modèle d'expression régulière essaie de correspondre plusieurs fois à n'importe quel caractère alphabétique, suivi par un caractère alphabétique spécifique.Because it matches any word character, the \w language element is often used with a lazy quantifier if a regular expression pattern attempts to match any word character multiple times, followed by a specific word character. Pour plus d’informations, consultez Quantificateurs.For more information, see Quantifiers.

L'exemple suivant utilise l'élément de langage \w pour le faire corresponde à des caractères en double dans un mot.The following example uses the \w language element to match duplicate characters in a word. L'exemple définit un modèle d'expression régulière, (\w)\1, qui peut être interprété comme suit.The example defines a regular expression pattern, (\w)\1, which can be interpreted as follows.

ÉlémentElement DescriptionDescription
(\w)(\w) Mettre en correspondance un caractère de mot.Match a word character. Il s'agit du premier groupe de capture.This is the first capturing group.
\1\1 Mettre en correspondance la valeur de la première capture.Match the value of the first capture.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer", 
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", 
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }                                                  
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(\w)\1"
      Dim words() As String = { "trellis", "seer", "latter", "summer", _
                                "hoarse", "lesser", "aardvark", "stunned" }
      For Each word As String In words
         Dim match As Match = Regex.Match(word, pattern)
         If match.Success Then
            Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                              match.Value, word, match.Index)
         Else
            Console.WriteLine("No double characters in '{0}'.", word)
         End If
      Next                                                  
   End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Caractère autre qu’un mot : \WNon-word character: \W

\W correspond à tout caractère autre qu'un caractère alphabétique.\W matches any non-word character. L'élément de langage \W est équivalent à la classe de caractères suivante :The \W language element is equivalent to the following character class:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]  

En d’autres termes, il correspond à n’importe quel caractère à l’exception de ceux inclus dans les catégories Unicode répertoriées dans le tableau suivant.In other words, it matches any character except for those in the Unicode categories listed in the following table.

CategoryCategory DescriptionDescription
LlLl Letter, LowercaseLetter, Lowercase
LuLu Letter, UppercaseLetter, Uppercase
LtLt Letter, TitlecaseLetter, Titlecase
LoLo Letter, OtherLetter, Other
LmLm Letter, ModifierLetter, Modifier
MnMn Mark, NonspacingMark, Nonspacing
NdNd Number, Decimal DigitNumber, Decimal Digit
PcPc Punctuation, Connector.Punctuation, Connector. Cette catégorie inclut dix caractères dont le plus souvent utilisé est le caractère LOWLINE (), u+005F.This category includes ten characters, the most commonly used of which is the LOWLINE character (), u+005F.

Si un comportement conforme à ECMAScript est spécifié, \W est équivalent à [^a-zA-Z_0-9].If ECMAScript-compliant behavior is specified, \W is equivalent to [^a-zA-Z_0-9]. Pour plus d’informations sur les expressions régulières ECMAScript, consultez la section « Comportement de correspondance ECMAScript » dans Options des expressions régulières.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

Notes

Étant donné qu'il correspond à n'importe quel caractère non alphabétique, l'élément de langage \W est souvent utilisé avec un quantificateur limitatif si un modèle d'expression régulière essaie de correspondre plusieurs fois à n'importe quel caractère non alphabétique suivi d'un caractère non alphabétique spécifique.Because it matches any non-word character, the \W language element is often used with a lazy quantifier if a regular expression pattern attempts to match any non-word character multiple times followed by a specific non-word character. Pour plus d'informations, consultez Quantificateurs.For more information, see Quantifiers.

L'exemple suivant illustre la classe de caractères \W.The following example illustrates the \W character class. Il définit un modèle d'expression régulière, \b(\w+)(\W){1,2}, qui correspond à un mot suivi d'un ou deux caractères non alphabétiques, comme un espace ou un signe de ponctuation.It defines a regular expression pattern, \b(\w+)(\W){1,2}, that matches a word followed by one or two non-word characters, such as white space or punctuation. L'expression régulière est interprétée comme indiqué dans le tableau suivant.The regular expression is interpreted as shown in the following table.

ÉlémentElement DescriptionDescription
\b\b Commencer la correspondance à la limite d'un mot.Begin the match at a word boundary.
(\w+)(\w+) Mettre en correspondance un ou plusieurs caractères alphabétiques.Match one or more word characters. Il s'agit du premier groupe de capture.This is the first capturing group.
(\W){1,2}(\W){1,2} Mettre en correspondance un caractère autre qu'un mot une ou deux fois.Match a non-word character either one or two times. Il s'agit du deuxième groupe de capture.This is the second capturing group.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value, 
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"), 
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\w+)(\W){1,2}"
      Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Value)
         Console.Write("   Non-word character(s):")
         Dim captures As CaptureCollection = match.Groups(2).Captures
         For ctr As Integer = 0 To captures.Count - 1
             Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                           Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                           If(ctr < captures.Count - 1, ", ", ""))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Étant donné que l'objet Group du deuxième groupe de capture ne contient qu'un seul caractère autre qu'un mot capturé, l'exemple extrait tous les caractères autres que des mots capturés de l'objet CaptureCollection retourné par la propriété Group.Captures.Because the Group object for the second capturing group contains only a single captured non-word character, the example retrieves all captured non-word characters from the CaptureCollection object that is returned by the Group.Captures property.

Espace : \sWhitespace character: \s

\s correspond à n'importe quel espace.\s matches any whitespace character. Il est équivalent aux séquences d'échappement et catégories Unicode répertoriées dans le tableau suivant.It is equivalent to the escape sequences and Unicode categories listed in the following table.

CategoryCategory DescriptionDescription
\f Saut de page, \u000C.The form feed character, \u000C.
\n Saut de ligne, \u000A.The newline character, \u000A.
\r Retour chariot, \u000D.The carriage return character, \u000D.
\t Tabulation, \u0009.The tab character, \u0009.
\v Tabulation verticale, \u000B.The vertical tab character, \u000B.
\x85 Points de suspension ou caractère À LA LIGNE (NEL) (…), \u0085.The ellipsis or NEXT LINE (NEL) character (…), \u0085.
\p{Z} Correspond à n'importe quel caractère de séparation.Matches any separator character.

Si un comportement conforme à ECMAScript est spécifié, \s est équivalent à [ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \s is equivalent to [ \f\n\r\t\v]. Pour plus d’informations sur les expressions régulières ECMAScript, consultez la section « Comportement de correspondance ECMAScript » dans Options des expressions régulières.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'exemple suivant illustre la classe de caractères \s.The following example illustrates the \s character class. Il définit un modèle d'expression régulière, \b\w+(e)?s(\s|$), qui correspond à un mot se terminant par "s" ou par "es", suivi d'un espace ou de la fin de la chaîne d'entrée.It defines a regular expression pattern, \b\w+(e)?s(\s|$), that matches a word ending in either "s" or "es" followed by either a white-space character or the end of the input string. L'expression régulière est interprétée comme indiqué dans le tableau suivant.The regular expression is interpreted as shown in the following table.

ÉlémentElement DescriptionDescription
\b\b Commencer la correspondance à la limite d'un mot.Begin the match at a word boundary.
\w+\w+ Mettre en correspondance un ou plusieurs caractères alphabétiques.Match one or more word characters.
(e)?(e)? Mettre en correspondance un « e » zéro ou une fois.Match an "e" either zero or one time.
ss Mettre en correspondance un « s ».Match an "s".
(\s|$)(\s|$) Mettre en correspondance un espace blanc ou la fin de la chaîne d’entrée.Match either a white-space character or the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b\w+(e)?s(\s|$)"
      Dim input As String = "matches stores stops leave leaves"
      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:
'       matches
'       stores
'       stops
'       leaves

Caractère autre qu’un espace : \SNon-whitespace character: \S

\S correspond à tout caractère autre qu'un espace.\S matches any non-white-space character. Il est équivalent au modèle d'expression régulière [^\f\n\r\t\v\x85\p{Z}] ou à l'opposé du modèle d'expression régulière qui est équivalent à \s, qui met en correspondance des espaces.It is equivalent to the [^\f\n\r\t\v\x85\p{Z}] regular expression pattern, or the opposite of the regular expression pattern that is equivalent to \s, which matches white-space characters. Pour plus d'informations, consultez Espace blanc : \s.For more information, see White-Space Character: \s.

Si un comportement conforme à ECMAScript est spécifié, \S est équivalent à [^ \f\n\r\t\v].If ECMAScript-compliant behavior is specified, \S is equivalent to [^ \f\n\r\t\v]. Pour plus d’informations sur les expressions régulières ECMAScript, consultez la section « Comportement de correspondance ECMAScript » dans Options des expressions régulières.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'exemple suivant illustre l'élément de langage \S.The following example illustrates the \S language element. Le modèle d'expression régulière \b(\S+)\s? met en correspondance des chaînes délimitées par des espaces blancs.The regular expression pattern \b(\S+)\s? matches strings that are delimited by white-space characters. Le deuxième élément de l'objet GroupCollection de la correspondance contient la chaîne correspondante.The second element in the match's GroupCollection object contains the matched string. L'expression régulière peut être interprétée comme indiqué dans le tableau suivant.The regular expression can be interpreted as shown in the following table.

ÉlémentElement DescriptionDescription
\b Commencer la correspondance à la limite d'un mot.Begin the match at a word boundary.
(\S+) Mettre en correspondance un ou plusieurs caractères autres que des espaces blancs.Match one or more non-white-space characters. Il s'agit du premier groupe de capture.This is the first capturing group.
\s? Mettre en correspondance zéro ou un espace blanc.Match zero or one white-space character.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " + 
                            "This is the second sentence.\n" + 
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(\S+)\s?"
      Dim input As String = "This is the first sentence of the first paragraph. " + _
                            "This is the second sentence." + vbCrLf + _
                            "This is the only sentence of the second paragraph."
      For Each match As Match In Regex.Matches(input, pattern)
         Console.WriteLine(match.Groups(1))
      Next
   End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Caractère numérique décimal : \dDecimal digit character: \d

\d correspond à n'importe quel chiffre décimal.\d matches any decimal digit. Il est équivalent au modèle d'expression régulière \p{Nd}, qui inclut les chiffres décimaux standard de 0 à 9, ainsi que les chiffres décimaux de plusieurs autres jeux de caractères.It is equivalent to the \p{Nd} regular expression pattern, which includes the standard decimal digits 0-9 as well as the decimal digits of a number of other character sets.

Si un comportement conforme à ECMAScript est spécifié, \d est équivalent à [0-9].If ECMAScript-compliant behavior is specified, \d is equivalent to [0-9]. Pour plus d’informations sur les expressions régulières ECMAScript, consultez la section « Comportement de correspondance ECMAScript » dans Options des expressions régulières.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'exemple suivant illustre l'élément de langage \d.The following example illustrates the \d language element. Il teste si une chaîne d'entrée représente un numéro de téléphone valide aux États-Unis et au Canada.It tests whether an input string represents a valid telephone number in the United States and Canada. Le modèle d'expression régulière ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ est défini comme indiqué dans le tableau suivant.The regular expression pattern ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ is defined as shown in the following table.

ÉlémentElement DescriptionDescription
^ Commencer la correspondance au début de la chaîne d'entrée.Begin the match at the beginning of the input string.
\(? Mettre en correspondance zéro ou un caractère littéral « ( ».Match zero or one literal "(" character.
\d{3} Mettre en correspondance trois chiffres décimaux.Match three decimal digits.
\)? Mettre en correspondance zéro ou un caractère littéral « ) ».Match zero or one literal ")" character.
[\s-] Mettre en correspondance un trait d'union ou un espace blanc.Match a hyphen or a white-space character.
(\(?\d{3}\)?[\s-])? Mettre en correspondance une parenthèse ouvrante facultative suivie de trois chiffres décimaux, d'une parenthèse fermante facultative et d'un espace blanc ou d'un tiret, zéro ou une fois.Match an optional opening parenthesis followed by three decimal digits, an optional closing parenthesis, and either a white-space character or a hyphen zero or one time. Il s'agit du premier groupe de capture.This is the first capturing group.
\d{3}-\d{4} Mettre en correspondance trois chiffres décimaux suivis d'un trait d'union et de quatre chiffres décimaux supplémentaires.Match three decimal digits followed by a hyphen and four more decimal digits.
$ Mettre en correspondance la fin de la chaîne d'entrée.Match the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444", 
                          "(212) 111-1111", "111-AB1-1111", 
                          "212-111-1111", "01 999-9999" };
      
      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern)) 
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
      Dim inputs() As String = { "111 111-1111", "222-2222", "222 333-444", _
                                 "(212) 111-1111", "111-AB1-1111", _
                                 "212-111-1111", "01 999-9999" }
      
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then 
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Caractère autre qu’un chiffre : \DNon-digit character: \D

\D correspond à n'importe quel caractère autre qu'un chiffre.\D matches any non-digit character. Il est équivalent au modèle d'expression régulière \P{Nd}.It is equivalent to the \P{Nd} regular expression pattern.

Si un comportement conforme à ECMAScript est spécifié, \D est équivalent à [^0-9].If ECMAScript-compliant behavior is specified, \D is equivalent to [^0-9]. Pour plus d’informations sur les expressions régulières ECMAScript, consultez la section « Comportement de correspondance ECMAScript » dans Options des expressions régulières.For information on ECMAScript regular expressions, see the "ECMAScript Matching Behavior" section in Regular Expression Options.

L'exemple suivant illustre l'élément de langage \D.The following example illustrates the \D language element. Il teste si une chaîne telle qu'un numéro de référence se compose de la combinaison appropriée de caractères décimaux et autres que des décimaux.It tests whether a string such as a part number consists of the appropriate combination of decimal and non-decimal characters. Le modèle d'expression régulière ^\D\d{1,5}\D*$ est défini comme indiqué dans le tableau suivant.The regular expression pattern ^\D\d{1,5}\D*$ is defined as shown in the following table.

ÉlémentElement DescriptionDescription
^ Commencer la correspondance au début de la chaîne d'entrée.Begin the match at the beginning of the input string.
\D Mettre en correspondance un caractère autre qu'un chiffre.Match a non-digit character.
\d{1,5} Mettre en correspondance de un à cinq chiffres décimaux.Match from one to five decimal digits.
\D* Mettre en correspondance zéro, un ou plusieurs caractères non décimaux.Match zero, one, or more non-decimal characters.
$ Mettre en correspondance la fin de la chaîne d'entrée.Match the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$"; 
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" }; 
      
      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "^\D\d{1,5}\D*$" 
      Dim inputs() As String = { "A1039C", "AA0001", "C18A", "Y938518" } 
      
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern) Then
            Console.WriteLine(input + ": matched")
         Else
            Console.WriteLine(input + ": match failed")
         End If   
      Next
   End Sub
End Module
' The example displays the following output:

Catégories générales Unicode prises en chargeSupported Unicode general categories

La norme Unicode définit les catégories générales répertoriées dans le tableau suivant.Unicode defines the general categories listed in the following table. Pour plus d’informations, consultez les sous-rubriques « Format de fichier UCD » et « Valeurs des catégories générales » dans la Base de données de caractères Unicode.For more information, see the "UCD File Format" and "General Category Values" subtopics at the Unicode Character Database.

CategoryCategory DescriptionDescription
Lu Letter, UppercaseLetter, Uppercase
Ll Letter, LowercaseLetter, Lowercase
Lt Letter, TitlecaseLetter, Titlecase
Lm Letter, ModifierLetter, Modifier
Lo Letter, OtherLetter, Other
L Toutes les lettres.All letter characters. Cela inclut les caractères Lu, Ll, Lt, Lm et Lo.This includes the Lu, Ll, Lt, Lm, and Lo characters.
Mn Mark, NonspacingMark, Nonspacing
Mc Mark, Spacing CombiningMark, Spacing Combining
Me Mark, EnclosingMark, Enclosing
M Toutes les signes diacritiques.All diacritic marks. Cela inclut les catégories Mn, Mc et Me.This includes the Mn, Mc, and Me categories.
Nd Number, Decimal DigitNumber, Decimal Digit
Nl Number, LetterNumber, Letter
No Number, OtherNumber, Other
N Tous les nombres.All numbers. Cela inclut les catégories Nd, Nl et No.This includes the Nd, Nl, and No categories.
Pc Punctuation, ConnectorPunctuation, Connector
Pd Punctuation, DashPunctuation, Dash
Ps Punctuation, OpenPunctuation, Open
Pe Punctuation, ClosePunctuation, Close
Pi Punctuation, Initial quote (peut se comporter comme Ps ou Pe selon l'utilisation)Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
Pf Punctuation, Final quote (peut se comporter comme Ps ou Pe selon l'utilisation)Punctuation, Final quote (may behave like Ps or Pe depending on usage)
Po Punctuation, OtherPunctuation, Other
P Tous les caractères de ponctuation.All punctuation characters. Cela inclut les catégories Pc, Pd, Ps, Pe, Pi, Pf et Po.This includes the Pc, Pd, Ps, Pe, Pi, Pf, and Po categories.
Sm Symbol, MathSymbol, Math
Sc Symbol, CurrencySymbol, Currency
Sk Symbol, ModifierSymbol, Modifier
So Symbol, OtherSymbol, Other
S Tous les symboles.All symbols. Cela inclut les catégories Sm, Sc, Sk et So.This includes the Sm, Sc, Sk, and So categories.
Zs Separator, SpaceSeparator, Space
Zl Separator, LineSeparator, Line
Zp Separator, ParagraphSeparator, Paragraph
Z Tous les caractères de séparation.All separator characters. Cela inclut les catégories Zs, Zl et Zp.This includes the Zs, Zl, and Zp categories.
Cc Other, ControlOther, Control
Cf Other, FormatOther, Format
Cs Other, SurrogateOther, Surrogate
Co Other, Private UseOther, Private Use
Cn Other, Not Assigned (aucun caractère n'a cette propriété)Other, Not Assigned (no characters have this property)
C Tous les caractères de contrôle.All control characters. Cela inclut les catégories Cc, Cf, Cs, Co et Cn.This includes the Cc, Cf, Cs, Co, and Cn categories.

Vous pouvez déterminer la catégorie Unicode de n'importe quel caractère particulier en passant ce caractère à la méthode GetUnicodeCategory.You can determine the Unicode category of any particular character by passing that character to the GetUnicodeCategory method. L'exemple suivant utilise la méthode GetUnicodeCategory pour déterminer la catégorie de chaque élément dans un tableau qui contient des caractères latins sélectionnés.The following example uses the GetUnicodeCategory method to determine the category of each element in an array that contains selected Latin characters.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };
      
      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), 
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim chars() As Char = { "a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c }
      
      For Each ch As Char In chars
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                           Char.GetUnicodeCategory(ch))
      Next         
   End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Blocs nommés pris en chargeSupported named blocks

.NET fournit les blocs nommés répertoriés dans le tableau suivant..NET provides the named blocks listed in the following table. Le jeu de blocs nommés pris en charge est basé sur Unicode 4.0 et Perl 5.6.The set of supported named blocks is based on Unicode 4.0 and Perl 5.6. Pour une expression régulière qui utilise des blocs nommés, consultez la section Catégorie Unicode ou bloc Unicode : \p{}.For a regular expression that uses named blocks, see the Unicode category or Unicode block: \p{} section.

Plage de points de codeCode point range Nom du blocBlock name
0000 - 007F0000 - 007F IsBasicLatin
0080 - 00FF0080 - 00FF IsLatin-1Supplement
0100 - 017F0100 - 017F IsLatinExtended-A
0180 - 024F0180 - 024F IsLatinExtended-B
0250 - 02AF0250 - 02AF IsIPAExtensions
02B0 - 02FF02B0 - 02FF IsSpacingModifierLetters
0300 - 036F0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF0370 - 03FF IsGreek

- ou --or-

IsGreekandCoptic
0400 - 04FF0400 - 04FF IsCyrillic
0500 - 052F0500 - 052F IsCyrillicSupplement
0530 - 058F0530 - 058F IsArmenian
0590 - 05FF0590 - 05FF IsHebrew
0600 - 06FF0600 - 06FF IsArabic
0700 - 074F0700 - 074F IsSyriac
0780 - 07BF0780 - 07BF IsThaana
0900 - 097F0900 - 097F IsDevanagari
0980 - 09FF0980 - 09FF IsBengali
0A00 - 0A7F0A00 - 0A7F IsGurmukhi
0A80 - 0AFF0A80 - 0AFF IsGujarati
0B00 - 0B7F0B00 - 0B7F IsOriya
0B80 - 0BFF0B80 - 0BFF IsTamil
0C00 - 0C7F0C00 - 0C7F IsTelugu
0C80 - 0CFF0C80 - 0CFF IsKannada
0D00 - 0D7F0D00 - 0D7F IsMalayalam
0D80 - 0DFF0D80 - 0DFF IsSinhala
0E00 - 0E7F0E00 - 0E7F IsThai
0E80 - 0EFF0E80 - 0EFF IsLao
0F00 - 0FFF0F00 - 0FFF IsTibetan
1000 - 109F1000 - 109F IsMyanmar
10A0 - 10FF10A0 - 10FF IsGeorgian
1100 - 11FF1100 - 11FF IsHangulJamo
1200 - 137F1200 - 137F IsEthiopic
13A0 - 13FF13A0 - 13FF IsCherokee
1400 - 167F1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F1680 - 169F IsOgham
16A0 - 16FF16A0 - 16FF IsRunic
1700 - 171F1700 - 171F IsTagalog
1720 - 173F1720 - 173F IsHanunoo
1740 - 175F1740 - 175F IsBuhid
1760 - 177F1760 - 177F IsTagbanwa
1780 - 17FF1780 - 17FF IsKhmer
1800 - 18AF1800 - 18AF IsMongolian
1900 - 194F1900 - 194F IsLimbu
1950 - 197F1950 - 197F IsTaiLe
19E0 - 19FF19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF1F00 - 1FFF IsGreekExtended
2000 - 206F2000 - 206F IsGeneralPunctuation
2070 - 209F2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF20A0 - 20CF IsCurrencySymbols
20D0 - 20FF20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

- ou --or-

IsCombiningMarksforSymbols
2100 - 214F2100 - 214F IsLetterlikeSymbols
2150 - 218F2150 - 218F IsNumberForms
2190 - 21FF2190 - 21FF IsArrows
2200 - 22FF2200 - 22FF IsMathematicalOperators
2300 - 23FF2300 - 23FF IsMiscellaneousTechnical
2400 - 243F2400 - 243F IsControlPictures
2440 - 245F2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F2500 - 257F IsBoxDrawing
2580 - 259F2580 - 259F IsBlockElements
25A0 - 25FF25A0 - 25FF IsGeometricShapes
2600 - 26FF2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF2700 - 27BF IsDingbats
27C0 - 27EF27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF2800 - 28FF IsBraillePatterns
2900 - 297F2900 - 297F IsSupplementalArrows-B
2980 - 29FF2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F3040 - 309F IsHiragana
30A0 - 30FF30A0 - 30FF IsKatakana
3100 - 312F3100 - 312F IsBopomofo
3130 - 318F3130 - 318F IsHangulCompatibilityJamo
3190 - 319F3190 - 319F IsKanbun
31A0 - 31BF31A0 - 31BF IsBopomofoExtended
31F0 - 31FF31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF3300 - 33FF IsCJKCompatibility
3400 - 4DBF3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48FA000 - A48F IsYiSyllables
A490 - A4CFA490 - A4CF IsYiRadicals
AC00 - D7AFAC00 - D7AF IsHangulSyllables
D800 - DB7FD800 - DB7F IsHighSurrogates
DB80 - DBFFDB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFFDC00 - DFFF IsLowSurrogates
E000 - F8FFE000 - F8FF IsPrivateUse ou IsPrivateUseAreaIsPrivateUse or IsPrivateUseArea
F900 - FAFFF900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4FFB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFFFB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0FFE00 - FE0F IsVariationSelectors
FE20 - FE2FFE20 - FE2F IsCombiningHalfMarks
FE30 - FE4FFE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6FFE50 - FE6F IsSmallFormVariants
FE70 - FEFFFE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEFFF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFFFFF0 - FFFF IsSpecials

Soustraction de classe de caractères : [groupe_base - [groupe_exclu]]Character class subtraction: [base_group - [excluded_group]]

Une classe de caractères définit un jeu de caractères.A character class defines a set of characters. La soustraction de classe de caractères produit un jeu de caractères qui est le résultat de l'exclusion des caractères d'une classe de caractères d'une autre classe de caractères.Character class subtraction yields a set of characters that is the result of excluding the characters in one character class from another character class.

Une expression de soustraction de classe de caractères a la forme suivante :A character class subtraction expression has the following form:

[ base_group -[ excluded_group ]][ base_group -[ excluded_group ]]

Les crochets ([]) et le trait d'union (-) sont obligatoires.The square brackets ([]) and hyphen (-) are mandatory. Le groupe_base est un groupe de caractères positif ou négatif.The base_group is a positive character group or a negative character group. Le composant groupe_exclu est un autre groupe de caractères positif ou négatif, ou une autre expression de soustraction de classe de caractères (autrement dit, vous pouvez imbriquer des expressions de soustraction de classe de caractères).The excluded_group component is another positive or negative character group, or another character class subtraction expression (that is, you can nest character class subtraction expressions).

Par exemple, supposons que vous disposiez d'un groupe de base composé de la plage de caractères « a » à « z ».For example, suppose you have a base group that consists of the character range from "a" through "z". Pour définir le jeu de caractères composé du groupe de base, à l'exception du caractère « m », utilisez [a-z-[m]].To define the set of characters that consists of the base group except for the character "m", use [a-z-[m]]. Pour définir le jeu de caractères composé du groupe de base, à l'exception du jeu de caractères « d », « j » et « p », utilisez [a-z-[djp]].To define the set of characters that consists of the base group except for the set of characters "d", "j", and "p", use [a-z-[djp]]. Pour définir le jeu de caractères composé du groupe de base, à l'exception de la plage de caractères allant de « m » à « p », utilisez [a-z-[m-p]].To define the set of characters that consists of the base group except for the character range from "m" through "p", use [a-z-[m-p]].

Prenons l'exemple de l'expression de soustraction de classe de caractères imbriquée, [a-z-[d-w-[m-o]]].Consider the nested character class subtraction expression, [a-z-[d-w-[m-o]]]. L'expression est évaluée à partir de la plage de caractères la plus profonde, vers l'extérieur.The expression is evaluated from the innermost character range outward. Tout d'abord, la plage de caractères « m » à « o » est soustraite de la plage de caractères « d » à « w », ce qui génère le jeu de caractères « d » à « l » et « p » à « w ».First, the character range from "m" through "o" is subtracted from the character range "d" through "w", which yields the set of characters from "d" through "l" and "p" through "w". Ce jeu est ensuite soustrait de la plage de caractères allant de « a » à « z », ce qui produit le jeu de caractères [abcmnoxyz].That set is then subtracted from the character range from "a" through "z", which yields the set of characters [abcmnoxyz].

Vous pouvez utiliser n'importe quelle classe de caractères avec la soustraction de classe de caractères.You can use any character class with character class subtraction. Pour définir le jeu de caractères qui se compose de tous les caractères Unicode de \u0000 à \uFFFF, à l'exception des espaces (\s), les caractères de la catégorie générale de ponctuation (\p{P}), les caractères du bloc nommé IsGreek (\p{IsGreek}) et le caractère de contrôle Unicode LIGNE SUIVANTE (\x85), utilisez [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].To define the set of characters that consists of all Unicode characters from \u0000 through \uFFFF except white-space characters (\s), the characters in the punctuation general category (\p{P}), the characters in the IsGreek named block (\p{IsGreek}), and the Unicode NEXT LINE control character (\x85), use [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Choisissez des classes de caractères pour une expression de soustraction de classe de caractères qui produira des résultats utiles.Choose character classes for a character class subtraction expression that will yield useful results. Évitez toute expression produisant un jeu de caractères vide, n'ayant aucune correspondance ou toute expression équivalant au groupe de base d'origine.Avoid an expression that yields an empty set of characters, which cannot match anything, or an expression that is equivalent to the original base group. Par exemple, le jeu vide résulte de l'expression [\p{IsBasicLatin}-[\x00-\x7F]], qui soustrait tous les caractères compris dans la plage de caractères IsBasicLatin de la catégorie générale IsBasicLatin.For example, the empty set is the result of the expression [\p{IsBasicLatin}-[\x00-\x7F]], which subtracts all characters in the IsBasicLatin character range from the IsBasicLatin general category. De même, le groupe de base d'origine résulte de l'expression [a-z-[0-9]].Similarly, the original base group is the result of the expression [a-z-[0-9]]. Cela est dû au fait que le groupe de base, c'est-à-dire la plage de caractères des lettres de « a » à « z », ne contient aucun caractère dans le groupe exclu, c'est-à-dire la plage de caractères des chiffres décimaux de « 0 » à « 9 ».This is because the base group, which is the character range of letters from "a" through "z", does not contain any characters in the excluded group, which is the character range of decimal digits from "0" through "9".

L'exemple suivant définit une expression régulière, ^[0-9-[2468]]+$, qui correspond à zéro et aux nombres impairs d'une chaîne d'entrée.The following example defines a regular expression, ^[0-9-[2468]]+$, that matches zero and odd digits in an input string. L'expression régulière est interprétée comme indiqué dans le tableau suivant.The regular expression is interpreted as shown in the following table.

ÉlémentElement DescriptionDescription
^ Commencer la correspondance au démarrage de la chaîne d'entrée.Begin the match at the start of the input string.
[0-9-[2468]]+ Mettre en correspondance une ou plusieurs occurrences de n'importe quel caractère de 0 à 9 à l'exception de 2, 4, 6 et 8.Match one or more occurrences of any character from 0 to 9 except for 2, 4, 6, and 8. En d'autres termes, mettre en correspondance une ou plusieurs occurrences de zéro ou d'un chiffre impair.In other words, match one or more occurrences of zero or an odd digit.
$ Terminer la correspondance à la fin de la chaîne d'entrée.End the match at the end of the input string.
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";
      
      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success) 
            Console.WriteLine(match.Value);
      }      
   }
}
// The example displays the following output:
//       13579753
//       335599901
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "123", "13579753", "3557798", "335599901" }
      Dim pattern As String = "^[0-9-[2468]]+$"
      
      For Each input As String In inputs
         Dim match As Match = Regex.Match(input, pattern)
         If match.Success Then Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

Voir aussiSee also