This is discussed at length in the Perl Cookbook, 2nd edition, recipe 6.18.

As to why, it is common for a program to accept a pattern as one of its arguments; in that case you cannot use $_ !~ /bar/ but must instead resort to:

/^(?:(?!bar).)*$/s
[download]

You say you can't use !~, but you don't really say why not. Does ! /$re/ suit you better?

my $re = qr/foo/;
my @no_match = grep { ! /$re/ } <INPUT>;
[download]

If the program that's calling the function is accepting a regex input by a user, requiring them to use '/^(?:(?!bar).)*$/s' when they want to find things that don't contain some word or phrase is not very friendly.

If the input is simple text, you might get away with passing "/^(?:(?!$their_input).)*$/s", thus wrapping their input in the appropriate construct if they specified 'NOT bar' or '!bar', or some flag to indicate that they want to invert the sense of the comparison. You'd have to strip the flag from the input before calling the function.

But if your going to have a flag they can use to indicate the inversion of the match, why not simply pass that flag through to the function and use it to determine the operator to use

sub do_selection{
    my( $flag, $match ) = @_;
    if( $flag ) {
        do_stuff if $data !~ $match;
    else {
        do_stuff if $data =~ $flag;
    }
}

my( $flag, $regex) = get_input();

do_selection( $flag, $regex );
[download]

That's the way grep -v works, which is a pretty good precedent.

I think that is a good suggestion. But perhaps it would be a good idea to take the flag as the second parameter (and use it optional) like this:

sub do_selection ($;$) {
    my $match = shift;
    my $flag  = shift || 0;

...
[download]

In this case you don't have to change lots of other calls of do_selection.

while (<DATA>) {
   chomp;
   print "$_ has no bar\n" if /^([^b]|b[^a]|ba[^r])+$/;
}

__DATA__
bar
foo
"bar" blah
baz "bar" blah
"test" blah
"test2"
[download]

Classic++, including classic mistakes. (:

Your regex will match "bbar" despite it containing "bar". "bb" matches b[^a] and then "a" and "r" each match [^b].

I started exploring this idea in depth and hope to write a lengthy node on it one day. Trying to fix the problems leads you down paths similar to:

/^([^b]|b[^a]| ba[^r])+$/
/^([^b]+|b+[^ab]| b+a[^rb])*b*a?$/
/^([^b]+|b+[^ab]|(b+a)+([^rb]|b+[^ab]))*[ba]*$/
[download]

- tye        

print "$_" if $_ =~ /(bar){0}/;

- - arden.

Update: Thanks hossman++, this is proof you shouldn't attempt regexes at 3am when you're sleep-walking.

Uh, no.

That will match every string, because "bar" 0 times is the empty string, and every input matches the empty string.

laptop:~> perl -le 'print "matches" if "bar" =~ /(bar){0}/;'
matches
laptop:~> perl -le 'print "also matches" if "barbar" =~ /(bar){0}/;'
also matches
laptop:~> perl -le 'print "event this matches" if "" =~ /(bar){0}/;'
event this matches
[download]