Comment trouver un mot non précédé d'un autre mot spécifique?

Question

Quelle expression régulière puis-je utiliser pour rechercher toutes les chaînes bar ne sont pas précédées de la chaîne foo? Avoir des espaces entre les deux est également illégal.

Ainsi, le regex doit correspondre aux chaînes suivantes

foo is bar 
hello bar 

Mais pas ces

foobar 
foo  bar 

J'ai essayé d'utiliser la

suivante

(?!<foo)bar 

et il obtient le travail accompli pour éliminer foobar, mais je dois prendre soin de l'espace, et bien sûr

(?!<foo)\s*bar 

correspond à toutes les chaînes.

Merci!

Answer 1

(?!<foo)\s*bar 

Cela correspondra les espaces blancs

Answer 2

php:

!preg_match(/foo\s*bar/,$string) && preg_match(/bar/,$string) 

perl:

$string !~ /foo\s*bar/ && $string =~ /bar/ 

Answer 3

Compte tenu de quelques cas de test

my @match = (
    "foo is bar", 
    "hello bar", 
); 

my @reject = (
    "foobar", 
    "foo  bar", 
); 

vous pouvez bien sûr faire en nourrissant les résultats d'un modèle à l'autre:

my @control = grep !/foo\s*bar/, grep /bar/ => @match, @reject; 

Nous pouvons aussi le faire avec un:

my $nofoo = qr/ 
    (  [^f] | 
    f (?! o) | 
    fo (?! o \s* bar) 
)* 
/x; 

my $pattern = qr/^ $nofoo bar /x; 

Mais ne prenez pas ma parole.

for (@match) { 
    print +(/$pattern/ ? "PASS" : "FAIL"), ": $_\n"; 
} 

for (@reject) { 
    print +(/$pattern/ ? "FAIL" : "PASS"), ": $_\n"; 
} 

Answer 4

Mieux vaut utiliser d'autres fonctions du langage de programmation que d'avoir trop tendance à rechercher un motif regex.

Vous recherchez des chaînes pour lesquelles $s =~ /bar/ and not $s =~ /foo\s*bar/ est vraie.

Le reste du script ci-dessous est juste à tester.

#!/usr/bin/perl 

use strict; use warnings; 

my %strings = (
    'foo is bar' => 1, 
    'hello bar' => 1, 
    'foobar'  => 0, 
    'foo  bar' => 0, 
    'barbar'  => 1, 
    'bar foo'  => 1, 
    'foo foo'  => 0, 
); 

my @accept = grep { $strings{$_} } keys %strings; 
my @reject = grep { not $strings{$_} } keys %strings; 

for my $s (@accept) { 
    if ($s =~ /bar/ and not $s =~ /foo\s*bar/) { 
     print "Good: $s\n"; 
    } 
    else { 
     print "Bad : $s\n"; 
    } 
} 

for my $s (@reject) { 
    if ($s =~ /bar/ and not $s =~ /foo\s*bar/) { 
     print "Bad : $s\n"; 
    } 
    else { 
     print "Good: $s\n"; 
    } 
} 

sortie:

 
E:\srv\unur> j 
Good: bar foo 
Good: hello bar 
Good: foo is bar 
Good: barbar 
Good: foo foo 
Good: foo  bar 
Good: foobar 

Answer 5

Prenant les informations de réponses précédentes, l'emballage en tant que perl one-liner, et en faisant les expressions régulières insensibles à la casse.

Windows:

perl -lne "print $_ if $_ !~ m/foo\s*bar/i && $_ =~ m/bar/i;" c:\temp\xx.txt 

Linux:

perl -lne 'print $_ if $_ !~ m/foo\s*bar/i && $_ =~ m/bar/i;' /tmp/xx.txt 

Avec xx.txt contenant:

foo is bar 
hello bar 
foobar 
foo  bar 
barbar 
bar foo 
barfoo 
foo foo 

Le résultat de l'exécution de la seule ligne à l'invite de commande:

foo is bar 
hello bar 
barbar 
bar foo 
barfoo