It is possible to put the inversion in the regexp, but I don't recommend it: it will in almost all cases be much less efficient.

Here's how it works: $string =~ /$re/ matches if $re matches at any point in the string; $string =~ /(?!$re)/ matches if there is any point in the string that does not match $re; $string =~ /^(?!.*$re)/s therefore matches only if there is no point in the string that matches $re, and is therefore the inverse.

Inverting outside the pattern just requires one of a couple of ways to ensure the interpreter knows it should do a pattern match:

grep !/$re/, @array;  # use // round $re to treat as a pattern match
grep $_ !~ $re, @array;  # use a negating match
[download]

Note that if $re is a precompiled regexp, perl won't need to recompile it just because you put // round it.

Hugo

• .* should be (?s:.*?).
  • Without /s, it could affect whether some strings match or not.
  • Without the non-greedy, it will affect the value of capture vars ($&, $1, etc) on a match. Not relevant in this case.
• ^ should be be \G
  • This will affect the number of matches when /g is used. Not relevant in this case.

Cool. Frontpaged the OP for this answer.

Purely from a syntax point of view, the following would work:

my @res = grep { !/$tmp/ } @array;
[download]

There is no good general way to negate a (Perl) regular expression. Negative lookahead/lookbehind like (?! and (?<! will easily fail for (say):

use 5.020;
use Data::Dumper;
my $tmp = qr/re/;

my @positive = grep {/$tmp/} 'rerere', 'foo';
my @negative = grep {/(?!$tmp)/} 'rerere', 'foo';

say Dumper \@positive; # 'rerere'
say Dumper \@negative; # 'rerere', 'foo'
[download]

In the past, whenever I wanted this I've used an external variable for the grep result like this:

use 5.020;
use Data::Dumper;
my $tmp = qr/re/;

my $reverse = 0; # 
my @positive = grep {!! /$tmp/ xor $reverse } 'rerere', 'foo';
$reverse = 1;
my @negative = grep {!! /$tmp/ xor $reverse } 'rerere', 'foo';

say Dumper \@positive; # 'rerere'
say Dumper \@negative; # 'foo'
[download]

There is no good general way to negate a (Perl) regular expression.

See my answer.

You could use

grep( !/$re/, @array )
[download]

grep( $_ !~ $re, @array )
[download]

What about something within the regex itself?

/$re/
[download]

/\G(?s:.*?)$re/
[download]

This is a form we can negate.

/\G(?!(?s:.*?)$re)/
[download]

So you could use

grep( /\G(?!(?s:.*?)$re)/, @array )
[download]