Explication détaillée des métacaractères des expressions régulières C#

Cet article organise les métacaractères des expressions régulières C#. Les expressions régulières sont des expressions composées de caractères. Chaque caractère représente une règle. Les caractères de l'expression sont divisés en deux types : les caractères ordinaires et les métacaractères. Les caractères ordinaires font référence à des caractères dont la signification littérale reste inchangée et correspondent au texte de manière exacte, tandis que les métacaractères ont des significations spéciales et représentent un type de caractère.

Considérez le texte comme un flux de caractères, chaque caractère étant placé à une position. Par exemple, dans l'expression régulière "Roomddd", les quatre premiers caractères Room sont des caractères ordinaires. . Le caractère suivant est un caractère d'échappement et forme un métacaractère d avec le caractère suivant d, indiquant qu'il y a un nombre à cette position.

décrit dans le langage des expressions régulières est : l'expression régulière "Roomddd" capture un total de 7 caractères, ce qui signifie "en commençant par Room, se terminant par Un type de chaîne se terminant par trois chiffres Nous appelons ce type de chaîne un motif (Pattern), également appelé motif régulier.

1. Caractères d'échappement

Les caractères d'échappement sont utilisés pour échapper des caractères ordinaires en métacaractères avec des significations spéciales. Les caractères d'échappement couramment utilisés sont :

t : Onglet horizontal

v : Onglet vertical

r : Retour chariot

n : Saut de ligne

\ : Représente un caractère, c'est-à-dire par exemple, échappe le caractère d'échappement en un caractère ordinaire

 : représente un caractère". En C#, les guillemets doubles sont utilisés pour définir des chaînes, et les guillemets doubles contenus dans une chaîne sont " pour représenter

2.

classe de caractères Lors de l'exécution d'une correspondance régulière, le texte saisi est considéré comme un flux de caractères séquentiels, les métacaractères de la classe de caractères correspondent aux caractères et capturent les caractères . Les soi-disant caractères capturés signifient que les caractères capturés par un métacaractère ne seront pas mis en correspondance par d'autres métacaractères, et les métacaractères suivants ne peuvent être extraits que du texte restant

Métacaractères de classe de caractères couramment utilisés :

[ char_group] : correspond à n'importe quel personnage du groupe de caractères

[^char_group] : correspond à l'exception de tout caractère en dehors du groupe de caractères

[premier-dernier] : correspond n'importe quel caractère dans la plage de caractères du premier au dernier, la plage de caractères comprend le premier et le dernier : caractère générique, correspond à n'importe quel caractère sauf n

w : correspond à n'importe quel caractère de mot, les caractères de mot font généralement référence à A-Z, a-z et. 0-9

W : correspond à n'importe quel caractère autre qu'un mot. Les caractères autres que A-Z, a-z et 0-9

s : correspond à n'importe quel caractère d'espacement

S : correspond à n'importe quel caractère non-espace

d : correspond à n'importe quel caractère numérique

D : correspond à n'importe quel caractère non numérique

Notez que les caractères d'échappement appartiennent également à la classe de caractères métacaractères. Lors d'une correspondance régulière, les personnages seront également capturés

3. Localisateur

L'objet correspondant (ou capturé) par le localisateur est la position. si la correspondance de modèle est réussie en fonction de la position du caractère. Le localisateur ne capture pas les caractères et a une largeur nulle (la largeur est 0). Les localisateurs couramment utilisés sont :

^ : par défaut. il correspond au début de la chaîne ; en mode multi-ligne, correspond à la position de début de chaque ligne

$ : Par défaut, correspond à la position de fin de la chaîne, ou à la position avant n avant la fin de ; la chaîne ; en mode multi-ligne, correspond à la position avant la fin de chaque ligne, ou à la position avant n à la fin de chaque ligne

A : correspond à la position de départ de la chaîne

.

Z : correspond à la position de fin de la chaîne, ou à la position avant n à la fin de la chaîne ;

z : correspond à la position de fin de la chaîne

G : correspond à la position de fin du match précédent ;

b : correspond à la position de début ou de fin d'un mot ;

B : correspond à la position médiane d'un mot ; 🎜>

4. Quantificateurs, cupidité et paresse

Les quantificateurs font référence à la limitation du nombre d'occurrences du modèle régulier précédent. Les quantificateurs sont divisés en deux modes. : le mode gourmand et le mode paresseux font référence à la correspondance avec autant de caractères que possible, tandis que le mode paresseux fait référence à la correspondance avec le moins de caractères possible. Par défaut, les quantificateurs sont en mode gourmand. Ajoutez ? après le quantificateur pour activer le mode paresseux.

* : apparaît 0 ou plusieurs fois

+ : apparaît 1 ou plusieurs fois

 ? : apparaît 0 ou 1 fois

{n } : Apparaît n fois

{n,} : Apparaît au moins n fois

{n,m} : Apparaît n à m fois

Remarque, apparaissant plusieurs fois signifie que le métacaractère précédent apparaît plusieurs fois. Par exemple, d{2} est équivalent à dd, seuls deux nombres apparaissent et il n'est pas nécessaire que les deux nombres soient identiques. Pour représenter les deux mêmes nombres, il faut utiliser le regroupement.

5. Regroupement et capture de personnages

() Les crochets déterminent non seulement la portée de l'expression, mais créent également des groupes. L'expression entre () est un groupe de référence signifie que le texte correspondant aux deux groupes est exactement le même. La syntaxe de base pour définir un groupe :

(pattern)

Ce type de regroupement capturera des caractères. Les caractères dits capturés font référence à : les caractères capturés par un métacaractère ne seront pas mis en correspondance par d'autres métacaractères suivants. obtenu de Rematch le texte restant.

1. Numérotation et dénomination des groupes

Par défaut, chaque groupe se voit automatiquement attribuer un numéro de groupe. Les règles sont : de gauche à droite, numérotation dans l'ordre dans lequel les parenthèses gauches du groupe. groupe apparaît. Un groupe a un numéro de groupe de 1, le second a un numéro de groupe de 2, et ainsi de suite. Vous pouvez également spécifier un nom pour le groupe. Ce groupe est appelé groupe nommé. Le groupe nommé sera également automatiquement numéroté. Le numéro commence par 1 et augmente de 1. La syntaxe pour spécifier un nom pour le groupe est la suivante. :

(?< name > pattern)

De manière générale, les groupes sont divisés en groupes nommés et en groupes numérotés. Les façons de référencer un groupe sont :

Pour référencer un groupe par nom de groupe : k

Pour référencer un groupe par numéro de groupe : numéro

Notez que les groupes ne peuvent être référencés qu'en arrière, c'est-à-dire qu'en commençant par le côté gauche du texte de l'expression régulière, le groupe doit d'abord être défini, puis il peut être référencé plus tard après la définition.

La syntaxe pour référencer les groupes dans les expressions régulières est "nombre". Par exemple, "1" représente le groupe correspondant à la sous-chaîne 1, "2" représente le groupe correspondant à la chaîne 2, et ainsi de suite.

Par exemple, "<(.*?)>.*?" peut correspondre à

valid

. le groupe est exactement le même.

2. Constructeur de regroupement

La méthode de construction de regroupement est la suivante :

(modèle) : capturez la sous-expression correspondante et attribuez un numéro de groupe au groupe

(?< name > pattern) : Capturez les sous-expressions correspondantes dans des groupes nommés

(?:pattern) : Groupes non capturants, dissociés et attribués à un numéro de groupe

(?> pattern) : regroupement gourmand

3. Regroupement gourmand

Le regroupement gourmand est également appelé regroupement sans retour en arrière. Ce regroupement désactive le retour en arrière. Le moteur d'expression régulière correspondra. autant de caractères que possible dans le texte saisi. Si aucune autre correspondance ne peut être effectuée, il n'est pas possible de revenir en arrière pour essayer des correspondances de modèles supplémentaires.

(?> pattern )

4. Choisissez l'un des deux

| signifie ou, faites correspondre l'un des deux. Notez que | divise les expressions des côtés gauche et droit en deux parties.

motif1 ｜ motif2

Six, assertion de largeur nulle

La largeur nulle signifie que la largeur est 0 et que la position correspond, donc la sous-chaîne correspondante n'apparaîtra pas dans les résultats de correspondance et l'assertion fait référence au résultat du jugement. Ce n'est que lorsque l'assertion est vraie que la correspondance peut être considérée comme réussie.

Pour les localisateurs, vous pouvez faire correspondre le début et la fin d'une phrase (^ $) ou faire correspondre le début et la fin d'un mot (b) Ces métacaractères. Correspondant uniquement à une position, spécifiant que la position satisfait à certaines conditions, plutôt que correspondant à certains caractères, elles sont donc appelées assertions de largeur nulle. La soi-disant largeur nulle signifie qu'ils ne correspondent à aucun caractère, mais correspondent à une position ; la soi-disant assertion fait référence à un jugement, et l'expression régulière continuera à correspondre uniquement lorsque l'assertion est vraie. Les assertions de largeur nulle peuvent correspondre à une position exacte, plutôt que de simplement spécifier une phrase ou un mot.

Les expressions régulières traitent le texte comme un flux de caractères de gauche à droite. La droite est appelée en arrière (Regarder derrière) , et la gauche est appelée en avant (Regarder en avant). ) . Pour les expressions régulières, uniquement lorsque le modèle spécifié (Pattern) correspond, l'assertion est True, ce qu'on appelle une expression positive, et le modèle sans correspondance est True, ce qu'on appelle une expression négative.

Les assertions de largeur nulle sont divisées en quatre types selon le sens de correspondance et la nature qualitative de la correspondance :

(?= modèle) : avant, assertion positive

(?! modèle) : avant, affirmation négative

(?<= modèle) : arrière, assertion positive

(?

1. Assertion positive avant

L'assertion positive avant définit qu'un modèle doit exister à la fin (ou sur le côté droit) du texte, mais que la sous-chaîne correspondant au modèle ne le sera pas apparaît Dans les résultats de correspondance, les assertions directes apparaissent généralement sur le côté droit de l'expression régulière, indiquant que le côté droit du texte doit satisfaire un modèle spécifique :

 (?= subexpression )

L'utilisation d'assertions positives directes peut déterminer une correspondance floue, le suffixe doit contenir des caractères spécifiques :

\b\w+(?=\sis\b)

Analyser les expressions régulières :

b : Indique la limite du mot

w+ : Indique que le mot apparaît au moins une fois

(?=sisb) : assertion positive directe, s représente un caractère d'espacement, is est un caractère ordinaire, une correspondance exacte et b est une limite de mot.

De l'analyse, on peut conclure que le texte correspondant à cette expression régulière doit contenir le mot is is est un mot distinct, et non une partie d'un mot. Donnez un exemple

Sunday is a weekend day 匹配该正则，匹配的值是Sunday，而The island has beautiful birds 不匹配该正则。

2、后向肯定断言

后向肯定断言定义一个模式必须存在于文本的开始（或左侧），但是该模式匹配的子串不会出现在匹配的结果中，后向断言通常出现在正则表达式的左侧，表示文本的左侧必须满足特定的模式：

(?<= subexpression )

使用后向肯定断言可以定一个模糊匹配，前缀必须包含特定的字符：

(?<=\b20)\d{2}\b

对正则表达式进行分析：

(?<=\b20)：后向断言，\b表示单词的开始，20是普通字符

\d{2}：表示两个数字，数字不要求相同

\b：单词的边界

该正则表达式匹配的文本具备的模式是：文本以20开头、以两个数字结尾。

七，用正则从格式化的文本中扣值

有如下的JSON格式的文本，从文本中扣出字段（CustomerId、CustomerName、CustomerIdSource和CustomerType）的值：

{"CustomerDetails":"[{\"CustomerId\":\"57512f19\",\"CustomerName\":\"cust xyz\",\"CustomerIdSource\":\"AadTenantId\",\"CustomerType\":\"Enterprise\"}]"}

注意，该文本转换为C#中的字符时，需要对双引号和转义字符进行转义。由于这四个字段提取规则相同，可以写一个通用的模式来提取：

public static string GetNestedItem(string txt, string key)
{
    string pat = string.Format("(?<=\\\\\"{0}\\\\\":\\\\\").*?(?=\\\\\")", key);
    return Regex.Match(txt, pat, RegexOptions.IgnoreCase).Value;
}

正则表达式得解析：

(?

.*?：懒惰模式，匹配尽可能少的文本

(?=\\\\\")：前向断言，用于匹配字段值得双引号

本文来自 C#.Net教程 栏目，欢迎学习！  

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!