Regexp correspondance des caractères majuscules, sauf une chaîne particulière

Question

que je veux faire correspondre toutes les lignes qui ont des caractères majuscules en eux, mais en ignorant la chaîne A_

Pour ajouter à la complication que je veux ignorer tout après une autre chaîne , par exemple un commentaire open

Voici des exemples de ce qui devrait et shouldnt rencontres

Correspondances:

• fooBar
• foo Bar foo
• A_fooBar
• fooBar/* Commentaire */

non Matches (C_ ne devrait pas déclencher un match)

• A_foobar
• foo A_bar
• foobar
• foo bar foo bar
• foobar/* Commentaire */

merci :)

Answer 1

Cela devrait (aussi?) Faire:

(?!A_)[A-Z](?!((?!/\*).)*\*/) 

Une brève explication:

(?!A_)[A-Z]  # if no 'A_' can be seen, match any uppercase letter 
(?!    # start negative look ahead 
    ((?!/\*).) # if no '/*' can be seen, match any character (except line breaks) 
    *    # match zero or more of the previous match 
    \*/   # match '*/' 
)    # end negative look ahead 

Ainsi, en clair E nglish:

Correspond à toute majuscule sauf 'A_' et aussi pas une majuscule si '* /' peut être vu sans rencontrer d'abord '/ *'.

Answer 2

Essayez:

(?<!A_)[a-zA-Z]+ 

(?!...) est appelé negative lookbehind.

En ce qui concerne votre problème, il est une sorte de tricherie, mais essayez:

^([#\.]|(?<!A_))[A-Za-z]{2,} 

je reçois:

fooBar => fooBar 
foo Bar foo => foo 
A_fooBar (no match) 
fooBar /* Comment */ => fooBar 
A_foobar (no match) 
foo A_bar => foo 
foobar => foobar 
foo bar foo bar => foo 
foobar /* Comment */ => foobar 

Answer 3

Celui-ci le fait, bien que la manipulation de commentaires ne sont pas extrêmement robuste. (Il suppose qu'un commentaire est toujours à la fin de la ligne.)

.*((A(?!_)|([B-Z]))(?<!/\*.*)).*\r\n 

Answer 4

-t-il être un seul regex? En Perl, vous pouvez faire quelque chose comme:

if (! $ String = ~/[AZ]/& & $ string ~/A_ /)

Son pas aussi cool comme une seule expression avec lookback, mais c'est probablement plus facile à lire et à maintenir.

Answer 5

Ma réponse:

/([B-Z]|A[^_]|A$)/ 

Je supprimerait le commentaire à un stade précoce, si possible.

Test:

#!perl 
use warnings; 
use strict; 

my @matches = (
"fooBar", 
"foo Bar foo", 
"A_fooBar", 
"fooBar /* Comment */"); 

my @nomatches = (
"A_foobar", 
"foo A_bar", 
"foobar", 
"foo bar foo bar", 
"foobar /* Comment */"); 

my $regex = qr/([B-Z]|A[^_]|A$)/; 

for my $m (@matches) { 
    $m =~ s:/\*.*$::; 
    die "FAIL $m" unless $m =~ $regex; 
} 
for my $m (@nomatches) { 
    $m =~ s:/\*.*$::; 
    die "FAIL $m" unless $m !~ $regex; 
} 

Essayez-le: http://codepad.org/EJhWtqkP

Answer 6

Essayez ceci:

^(?:[^A-Z/]|A_|/(?!\*))*+[A-Z] 

Cela fonctionne dans toute la saveur qui prend en charge quantificateurs possessifs, par exemple PowerGrep, Java et PHP. La saveur de .NET ne est pas, mais il ne supporte des groupes atomiques:

^(?>(?:[^A-Z/]|A_|/(?!\*))*)[A-Z] 

Si aucune de ces fonctionnalités est disponible, vous pouvez utiliser un autre test avant pour l'empêcher correspondant à la A_ sur le rebond:

^(?:[^A-Z/]|A_|/(?!\*))*(?!A_)[A-Z]