Qu'est-ce qu'un "Quantifier imbriqué" et pourquoi fait-il échouer mon regex?

Question

J'ai cette regex, j'ai construit et testé dans buddy regex.

"_ [ 0-9]{10}+ {1}+[ 0-9]{10}+ {2}+[ 0-9]{6}+ {2}[ 0-9]{2}" 

Quand j'utiliser dans .Net C#

Je reçois l'exception

"parsing \"_ [ 0-9]{10}+ +[ 0-9]{10}+ +[ 0-9]{6}+ [ 0-9]{2}\" - Nested quantifier +." 

Que signifie cette erreur? Apparemment, .net n'aime pas l'expression.

est ici le copain de regex si u peut comprendre mon intention avec le motif ...

_ [ 0-9]{10}+ {1}+[ 0-9]{10}+ {2}+[ 0-9]{6}+ {2}[ 0-9]{2} 

Match the characters "_ " literally «_ » 
Match a single character present in the list below «[ 0-9]{10}+» 
    Exactly 10 times «{10}+» 
    The character " " « » 
    A character in the range between "0" and "9" «0-9» 
Match the character " " literally « {1}+» 
    Exactly 1 times «{1}+» 
Match a single character present in the list below «[ 0-9]{10}+» 
    Exactly 10 times «{10}+» 
    The character " " « » 
    A character in the range between "0" and "9" «0-9» 
Match the character " " literally « {2}+» 
    Exactly 2 times «{2}+» 
Match a single character present in the list below «[ 0-9]{6}+» 
    Exactly 6 times «{6}+» 
    The character " " « » 
    A character in the range between "0" and "9" «0-9» 
Match the character " " literally « {2}» 
    Exactly 2 times «{2}» 
Match a single character present in the list below «[ 0-9]{2}» 
    Exactly 2 times «{2}» 
    The character " " « » 
    A character in the range between "0" and "9" «0-9» 

En bref ...

Qu'est-ce qu'un Nested quantificateurs?

Answer 1

.NET se plaint du + après le quantificateur de style {n} car cela n'a aucun sens. {n} signifie correspondre exactement n d'un groupe donné. + signifie correspondre à un ou plusieurs d'un groupe donné. Enlevez les + et ça va bien se compiler.

"_ [ 0-9]{10} {1}[ 0-9]{10} {2}[ 0-9]{6} {2}[ 0-9]{2}" 

Answer 2

Ils ont raison. Cette version de votre regex ne manque pas:

(_ [ 0-9]{10})+(\s{1})+([ 0-9]{10})+(\s{2})+([ 0-9]{6})+\s{2}[ 0-9]{2}

Notez l'utilisation de parens pour créer des groupes qui peuvent ensuite répéter une ou plusieurs fois. En outre, vous devriez être plus précis et utiliser \ s à la place d'un espace, car les espaces de motif peuvent avoir ou non une signification.

BTW, cette regex ne semble pas si utile. Vous voudrez peut-être poser une autre question du type "Comment utiliser regex pour correspondre à ce modèle?"

Answer 3

.NET ne prend pas en charge le possessive quantifier

{10}+ 

Cependant, {10} doit avoir exactement le même effet. Le + évite de revenir en arrière et d'essayer des correspondances plus courtes si la correspondance la plus longue échoue, mais puisque {10} ne peut correspondre exactement qu'à 10 caractères pour commencer, cela n'obtient pas beaucoup de résultats.

"_ [ 0-9]{10} [ 0-9]{10} {2}[ 0-9]{6} {2}[ 0-9]{2}" 

devrait être bien. J'ai également supprimé le bit "{1} +". Comme il correspond exactement une fois, "A {1} +" équivaut à "A".

EDIT Comme le dit Porges, si vous avez besoin quantificateurs possessifs dans .NET, puis des groupes atomiques donnent la même fonctionnalité avec (>[0-9]*) équivalente à [0-9]*+.

Answer 4

Si vous sélectionnez la saveur .NET dans la barre d'outils en haut dans RegexBuddy, RegexBuddy indiquera que .NET ne prend pas en charge les quantificateurs possessifs tels que {10} +.

Puisque {10} n'autorise qu'un nombre spécifique de répétitions, le rendre paresseux ou possessif est inutile, même s'il est syntaxiquement valide dans les arômes regex qui supportent les quantificateurs paresseux et/ou possessive. En supprimant les signes + de votre expression régulière, cela fonctionnera correctement avec .NET.

Dans d'autres situations, double-cliquez sur l'erreur concernant le quantificateur possessif dans l'onglet Créer de RegexBuddy. RegexBuddy remplacera alors le quantificateur possessive par un groupe atomique fonctionnellement équivalent. Si vous générez un extrait de code source pour un langage .NET sous l'onglet Utiliser dans RegexBuddy, RegexBuddy remplacera automatiquement les quantificateurs possessifs dans l'expression régulière dans l'extrait de code source.