assorti doubles ombles chaînes délimitées avec des expressions régulières

Question

Supposons que vous voulez faire correspondre le texte qui est délimité par des caractères doubles comme ceci: (. *)

a = << 
Hello 
World! 
>> 

L'expression régulière/< < >>/sembleraient faire , mais malheureusement, quand ceux-ci peuvent être répétées correspondant avide devient trop:

a = << 
Hello 
World! 
>> 

b = << 
Goodbye 
World! 
>> 

précédent regexp capture

Hello 
World! 
>> 

b = << 
Goodbye 
World! 

La réponse évidente est de faire le regexp non gourmand: (. *?)/< < >>/

Malheureusement, cela a des problèmes de performances extrêmes pour les longues chaînes (en Perl au moins). Si les délimiteurs étaient des caractères uniques, nous pourrions utiliser une classe de caractères (tout sauf le caractère) pour résoudre le problème glouton.

Des idées sur une expression régulière pour faire correspondre ce match sans la pénalité de performance?

NB: je dois utiliser Perl et cela doit être une expression régulière en raison du système plus grand, il est intégré dans

Merci..

Answer 1

Veuillez voir si les performances d'un analyseur dédié (tel que Text::Balanced) seraient acceptables dans ce cas. Ce n'est pas regex, mais sans plus de détails sur votre post-scriptum "NB" il semble que vous pourriez avoir un XY problem lorsque vous cherchez une solution regex seulement.

Si vous devez absolument utiliser une regex, veuillez utiliser une fonctionnalité de prévisualisation - cela peut améliorer la vitesse.

Answer 2

Utilisation d'une classe de caractères niée dans ce cas ne fonctionnera: cependant

/<<([^>]*)>>/ est la même sonde nombre que /<<(.*)>>/ devrait donc être tout aussi rapide avec moins de retours en arrière comme /<<(.*?)>>/

Je suis d'accord avec DVK; est une regex le seul moyen?

Answer 3

L'expansion de la réponse de drewk il fonctionne réellement:

/<<((?:(?>[^>]+)|>(?!>))*)>>/ 

Match « < < », puis une séquence de 0 ou plusieurs morceaux qui sont soit un nombre quelconque de non - caractères « > », ou un " > "pas suivi d'un autre"> ", puis finalement" >> ".

Answer 4

Supposons que vous avez une grammaire simple

my $p = Parse::RecDescent->new(<<'EOGrammar'); 
    program: assignment(s) 

    assignment: id '=' '<<' angle_text '>>' 
       { $return = [ $item{id}, $item{angle_text} ] } 

    angle_text: <skip:undef>/([^>] | >(?!>))* /x 

    id: /\w+/ 
EOGrammar 

et un texte source

a = << 
Hello 

World! 

>> 

b = << 


Goodbye 
World! 
>> 

Lorsque vous traitez le résultat avec

for (@{ $p->program($text) }) { 
    my($name,$what) = @$_; 
    print "$name: [[[$what]]]\n"; 
} 

vous verrez la sortie de

a: [[[ 
Hello 

World! 

]]] 
b: [[[ 


Goodbye 
World! 
]]]

Answer 5

Utilisez-vous Perl 5.10? Essayez ceci:

/<<([^>]*+(?:>(?!>)[^>]*+)*+)>>/ 

Comme les @hobbs regex affichés, celui-ci effectue seulement après qu'il trouve préanalyse une > (par opposition à la quantificateur non gourmand, qui réalise effectivement une préanalyse à chaque position). Mais celui-ci utilise la technique de «boucle déroulée» de Friedl, qui devrait être légèrement plus rapide que l'approche de l'alternance. De plus, tous les quantificateurs sont possessifs, donc cela ne dérange pas de sauvegarder les informations d'état qui rendraient le retour en arrière possible.