[Tutoriel C#] Expressions régulières C#

Expression régulière C#

L'expression régulière est un modèle qui correspond au texte saisi. Le framework .Net fournit un moteur d'expression régulière qui permet une telle correspondance. Un modèle se compose d'un ou plusieurs caractères, opérateurs et structures.

Définition des expressions régulières

Vous trouverez ci-dessous les différentes catégories de caractères, opérateurs et structures utilisées pour définir les expressions régulières.

Évasion de personnage

Classe de personnage

Ancre

Construction de groupe

Qualificateur

Construction de référence arrière

Construction alternative

Remplacement

Construction diverse

Échappement de caractère

Caractère barre oblique inverse dans une expression régulière () Indique que le caractère qui le suit est un caractère spécial ou doit être interprété littéralement.

Le tableau suivant répertorie les caractères d'échappement :

Caractère d'échappement

Description

Motif

Correspondance

a correspond au symbole d'alarme (cloche) u0007. un "Attention!" "u0007" dans 'u0007'

b dans la classe de caractères, correspond à la touche retour arrière u0008. [b]{3,} "bbbb" dans "bbbb"

t correspond au caractère de tabulation u0009. (w )t "Namet" et "Addrt" dans "NametAddrt"

r correspondent au caractère de retour chariot u000D. (r n'est pas équivalent au caractère de nouvelle ligne n.) rn(w ) "rnHello" dans "rHellonWorld"

v correspond au caractère de tabulation verticale u000B. [v]{2,} "vvv" dans "vvv"

f correspond au caractère de saut de formulaire u000C. [f]{2,} "fff" dans "fff"

n correspond au caractère de nouvelle ligne u000A. rn(w) "rnHello" dans "rHellonWorld."

e correspond au caractère d'échappement u001B. e "x001B" dans "x001B"

nnn spécifie un caractère utilisant une représentation octale (nnn se compose de deux à trois chiffres). w

p{ name } correspond à n'importe quel caractère unique de la catégorie universelle Unicode ou du bloc nommé spécifié par name . Le "C" et le "L" dans p{Lu} "City Lights"

P{ name } correspondent à tout caractère unique qui ne fait pas partie de la catégorie universelle Unicode ou du bloc nommé spécifié par son nom. P{Lu} "i", "t" et "y" dans "City"

w correspondent à n'importe quel caractère de mot. w "R", "o", "m" et "1" dans "Room#1"

W correspond à n'importe quel caractère autre qu'un mot. Le "#" dans W "Room#1"

s correspond à n'importe quel caractère d'espacement. Le "D" dans ws "ID A1.3"

S correspond à tout caractère autre qu'un espace. sS Le " _" dans "int __ctr"

d correspond à n'importe quel chiffre décimal. d Le "4" dans "4 = IV"

D correspond à tout caractère qui n'est pas un nombre décimal. D " ", "=", " ", "I" et "V" dans "4 = IV"

point d'ancrage

point d'ancrage ou assertion atomique de largeur nulle fera la correspondance réussissent ou échouent, selon la position actuelle dans la chaîne, mais ils ne font pas avancer le moteur dans la chaîne ni utiliser de caractères.

Le tableau suivant répertorie les points d'ancrage :

Assertion

Description

Modèle

Match

^ La correspondance doit commencer au début de la chaîne ou de la ligne. ^d{3} "567" dans "567-777-"

$ La correspondance doit apparaître à la fin de la chaîne ou avant n à la fin de la ligne ou de la chaîne. -d{4}$ "-2012" dans "8-12-2012"

A La correspondance doit apparaître au début de la chaîne. Aw{3} "Code" dans "Code-007-"

Z La correspondance doit apparaître en fin de chaîne ou avant n à la fin de la chaîne. -d{3}Z "-007" dans "Bond-901-007"

z La correspondance doit apparaître à la fin de la chaîne. -d{3}z "-333" dans "-901-333"

G La correspondance doit apparaître à la fin de la correspondance précédente. \G(d) "(1)", "(3)" et "(5)" dans "(1)(3)(5)(7](9)"

b doit correspondre Se produit sur la limite entre les caractères w (alphanumériques) et W (non alphanumériques). w "R", "o", "m" et "1" dans "Room#1"

Les correspondances B ne doivent pas avoir lieu sur la limite b. Bendw*b "ends" et "ender" dans "end sends endure lender"

Construction de groupe

La construction de groupe décrit une sous-expression d'une expression régulière, généralement utilisée pour capturer les caractères d'entrée Une sous-chaîne de une chaîne.

Le tableau suivant répertorie les constructions de regroupement :

Constructions de regroupement

Description

Modèle

Match

( sous-expression) Capture la sous-expression correspondante et l'attribue à un numéro de séquence de base zéro. (w)1 "ee" dans "deep"

(?ffa311f4d315fdfef0e6b8f6e78c67c5sous-expression) Capture les sous-expressions correspondantes dans un groupe nommé. (?f5fbfbee748f450acbec5bd3114a2e8bw)kf5fbfbee748f450acbec5bd3114a2e8b "ee" dans "deep"

(?30a878cd74d918ee999c6783be1410a8subexpression) définit la définition du groupe d'équilibrage. (((?'Ouvrir'()[^()]*) ((?'Fermer-Ouvrir'))[^()]*) )*(?(Ouvrir)(?!))$ "3 2^ "((1-3)*(3-1))" in ((1-3)*(3-1))"

(?: sous-expression) définit un groupe non capturant. Write(?:Line)? "WriteLine" in "Console.WriteLine()"

(?imnsx-imnsx:subexpression) Applique ou désactive les options spécifiées dans subexpression . Ad{2}(?i:w )b "A12xl" et "A12XL" dans "A12xl A12XL a12xl"

(?= sous-expression) Assertion d'anticipation positive de largeur nulle. w (?=.) "est", "a couru" et "dehors" dans "Il est. Le chien a couru. Le soleil est sorti

.

(?! sous-expression) Assertion d'anticipation négative de largeur nulle. b(?!un)w b "sûr" et "utilisé" dans "pas sûr que l'unité soit utilisée"

(?b3ab9acd4da6c21a9a52f6609c9da8dd sous-expression) Expression de sous-expression sans retour en arrière (également appelée "gourmand") . [13579](?>A B ) "1ABB", "3ABB" et "5AB" dans "1ABB 3ABBC 5AB 5AC"

qualificatif

le qualificatif est spécifié dans la chaîne d'entrée Combien d'instances de l'élément précédent (qui peut être un caractère, un groupe ou une classe de caractères) doit exister pour qu'une correspondance se produise. Les qualificatifs incluent les éléments linguistiques répertoriés dans le tableau suivant.

Le tableau suivant répertorie les qualificatifs :

Qualificateur

Description

Modèle

Match

* Correspond à l'élément précédent zéro ou plusieurs fois. d*.d ".0", "19.9", "219.9"

Correspond à l'élément précédent une ou plusieurs fois. "be" "bee" dans "been", "be" dans "bent"

Correspond à l'élément précédent zéro ou une fois. "rai?n" "ran", "rain"

{ n } Correspond à l'élément précédent exactement n fois. ",d{3}" ",043" dans "1,043.6", ",876", ",543" et ",210" dans "9,876,543,210"

{ n ,} Correspond à l'élément précédent Au moins n fois. "d{2,}" "166", "29", "1930"

{ n , m } Correspond à l'élément précédent au moins n fois, mais pas plus de m fois. "19302" dans "d{3,5}" "166", "17668", "193024"

* ? Correspond à l'élément précédent zéro ou plusieurs fois, mais aussi peu de fois que possible. d*?.d ".0", "19.9", "219.9"

? Faire correspondre l'élément précédent une ou plusieurs fois, mais aussi peu de fois que possible. "be ?" "be" dans "been", "be" dans "bent"

?? Correspond à l'élément précédent zéro ou une fois, mais le moins de fois possible. "rai??n" "ran", "rain"

{ n } Correspond à l'élément principal exactement n fois. ",d{3}?" ",043" dans "1,043.6", ",876", ",543" et ",210" dans "9,876,543,210"

{ n ,} ? au moins n fois, mais aussi peu de fois que possible. "d{2,}?" "166", "29" et "1930"

{ n , m } ? Le nombre de fois pour faire correspondre l'élément précédent est compris entre n et m, mais le nombre de les temps sont aussi petits que possible. "d{3,5}?" "166", "17668", "193" et "024" dans "193024"

Construction de référence arrière

Les références arrière sont autorisées dans les identifications ultérieures précédemment correspondantes sous-expressions au sein de la même expression régulière.

Le tableau suivant répertorie les constructions de référence arrière :

Construction de référence arrière

Description

Modèle

Correspondances

référence arrière du numéro. Correspond à la valeur de la sous-expression numérique. (w)1 "ee" dans "seek"

k8791d3330d234d527a27eca9e448f0b5w)k371aa25074d3a749602b343134e651a8 "ee" dans "seek"

Constructions alternatives

Les constructions alternatives sont utilisées pour modifier les expressions régulières pour activer la correspondance.

Le tableau suivant répertorie les constructions alternatives :

Constructions alternatives

Description

Modèle

Match

| Correspond à tout élément séparé par une barre verticale (|). "le" et "ceci" dans th(e|is|at) "c'est le jour".

(?( expression )yes | no ) Correspond à yes si le modèle d'expression régulière est spécifié par expression matching ; sinon, correspond à la partie facultative no ; L'expression est interprétée comme une assertion de largeur nulle. (?(A)Ad{2}b|bd{3}b) "A10" et "910" dans "A10 C103 910"

(?( nom)oui | non ) Si nom ou a des correspondances yes si le groupe de capture nommé ou numéroté a une correspondance, sinon correspond au no facultatif ; (?8174eb389256bda2551b9af114d34f45")?(?(cité). ?"|S s) "Dogs.jpg "Yiska Playing.jpg"" dans Dogs.jpg et "Yiska Playing.jpg"

Remplacement

Le remplacement est une expression régulière utilisée dans les modèles de remplacement.

Le tableau suivant répertorie les caractères utilisés pour la substitution :

Caractère

Description

Modèle

Remplacement pattern

Chaîne d'entrée

Chaîne de résultat

$numéro Remplace les sous-chaînes correspondant au numéro de groupe. b(w )(s)(w )b $3$2$1 "one two" "two one"

${name} Remplace les sous-chaînes correspondant au nom du groupe nommé. b(?bc50d2b8e0f6f0a16aa7662b92d4f696w )(s)(?389baf92d469489f3e373ca0f6c49feaw )b ${word2} ${word1} "un deux" "deux un"

$$ Remplacer le caractère "$" . b(d )s?USD $$$1 "103 USD" "$103"

$& Remplace la correspondance entière par une copie. ($*(d*(. d )?){1}) **$& "$1.30" "**$1.30**"

$` Remplacez tout le texte de la chaîne d'entrée avant la correspondance. B $` "AABBCC" "AAAACC"

$' Remplace tout le texte de la chaîne d'entrée correspondante. B $' "AABBCC" "AACCC"

$ Remplace le dernier groupe capturé. B (C) $ "AABBCCDD" AACCDD

$_ Remplace la chaîne d'entrée entière. B $_ "AABBCC" "AAAABBCCCC"

Constructions diverses

Le tableau suivant répertorie diverses constructions diverses :

Construction

Description

Instance

(?imnsx-imnsx) Définissez ou désactivez des options telles que l'insensibilité à la casse au milieu du mode. bA(?i)bw b correspond à "ABA" et "Able" dans "ABA Able Act"

(?#comment) Commentaire en ligne. Le commentaire se termine à la première parenthèse fermante. bA(?#Correspond aux mots commençant par A)w b

# [à la fin de la ligne] Commentaire en mode X. Le commentaire commence par un # sans échappement et continue jusqu'à la fin de la ligne. (?x)bAw b#Correspond aux mots commençant par A

Classe Regex

La classe Regex est utilisée pour représenter une expression régulière.

Le tableau suivant répertorie certaines méthodes couramment utilisées dans la classe Regex :

Numéro de série

Méthode et description

1 public bool IsMatch( string input )
Indique si l'expression régulière spécifiée dans le constructeur Regex trouve une correspondance dans la chaîne d'entrée spécifiée.

2 public bool IsMatch( string input, int startat )
Indique si l'expression régulière spécifiée dans le constructeur Regex trouve une correspondance dans la chaîne d'entrée spécifiée, en commençant à la position de départ spécifiée dans le début de la chaîne.

3 public static bool IsMatch( string input, string pattern)
Indique si l'expression régulière spécifiée trouve une correspondance dans la chaîne d'entrée spécifiée.

4 correspondances MatchCollection publiques (entrée de chaîne)
Recherchez toutes les correspondances de l'expression régulière dans la chaîne d'entrée spécifiée.

5 chaîne publique Remplacer (entrée de chaîne, remplacement de chaîne)
Dans la chaîne d'entrée spécifiée, remplacez toutes les chaînes correspondantes correspondant au modèle d'expression régulière par la chaîne de remplacement spécifiée.

6 public string[] Split( string input)
Divisez la chaîne d'entrée en un tableau de sous-chaînes en fonction des positions définies par le modèle d'expression régulière spécifié dans le constructeur Regex.

Pour une liste complète des propriétés de la classe Regex, consultez la documentation C# de Microsoft.

Exemple 1

L'exemple suivant correspond aux mots commençant par 'S' :

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "A Thousand Splendid Suns";

         Console.WriteLine("Matching words that start with 'S': ");
         showMatch(str, @"\bS\S*");
         Console.ReadKey();
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns

实例 2

下面的实例匹配了以 'm' 开头以 'e' 结尾的单词：

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure

实例 3

下面的实例替换掉多余的空格：

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input = "Hello   World   ";
         string pattern = "\\s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：

Original String: Hello   World   
Replacement String: Hello World

 以上就是【c#教程】C# 正则表达式的内容，更多相关内容请关注PHP中文网（www.php.cn）！