From perlre:

(?!pattern)
A zero-width negative lookahead assertion. For example /foo(?!bar)/ matches any occurrence of ``foo'' that isn't followed by ``bar''. Note however that lookahead and lookbehind are NOT the same thing. You cannot use this for lookbehind.

Perhaps you mean to use the (?<!pattern) look behind assertion?

More From perlre:

(?<!pattern)
A zero-width negative lookbehind assertion. For example /(?<!bar)foo/ matches any occurrence of ``foo'' that isn't following ``bar''. Works only for fixed-width lookbehind.

-Ben Jacobs (dooberwah)
http://dooberwah.perlmonk.org
"one thing i can tell you is you got to be free"

Actually, lookbehind and lookahead seem to be the same when the assertion itself has zero-width... In the following code, looking ahead for the anchor produces the same results as looking behind for it.

#!/usr/bin/perl -wT
use strict;

# Replace 'See' anywhere in the string
$_ = "See spot run.  See spot jump.";
s/See/MATCH/g;
print "'$_'\n";          # 'MATCH spot run.  MATCH spot jump.'

# Replace 'See' unless lookahead finds the anchor
$_ = "See spot run.  See spot jump.";
s/(?!^)See/MATCH/g;
print "'$_'\n";          # 'See spot run.  MATCH spot jump.'

# Replace 'See' unless lookabehind finds the anchor
$_ = "See spot run.  See spot jump.";
s/(?<!^)See/MATCH/g;     # 'See spot run.  MATCH spot jump.'
print "'$_'\n";
[download]

-Blake

When having a zero-width pattern inside the assertion it doesn't matter in which direction you look. It's zero width. It's like saying that you jump 0 meters up in the air, or 0 meters down into the ground. You're still not moving. Sure, it might make more sense to say you jumped 0 meter up from the ground than down in the ground, but effectively it's still the same thing.

I used look-ahead because if I recall correct it's faster, and it was supposted to be fast. Plus it's one byte shorter, and he wanted prettiness. I consider (?!) prettier than (?<!).

Cheers,
-Anomo

Instead of just trusting the documentation I went and did my own tests on differences in regex assertions. Here are my results:

dooberwah@kyle:~$ perl -e 'print "foobar" =~ /(?<=foo)bar/, "\n";'
1
dooberwah@kyle:~$ perl -e 'print "foobar" =~ /(?=foo)bar/, "\n";'

dooberwah@kyle:~$
[download]

As you can see, trying to use a look-ahead assertion in place of a look-behind assertion yealds no results. I certainly hope that we're still talking about the same thing. You got me a little confused with the jumping analogy :-). If your actually talking about something different please just tell me.

-Ben Jacobs (dooberwah)
http://dooberwah.perlmonk.org
"one thing i can tell you is you got to be free"

Examining the output of re 'debug' made me realize that there's not speed difference between the look-ahead and look-behind. At least not on my perl.

-Anomo