INPUT: while (<IN>) {
 for my $match (@list) {
  next INPUT if /$match/;
 }
 print;
}
[download]

my $re = join "|", @list;
while ... {
 print unless /$re/;
}
[download]

To be more idiomatic, you should ensure that your @list doesn't contain anything that will get the regex bent out of shape. A simple application of quotemeta will help set things straight:

my $re = join ("|", map {quotemeta} @list);
while (...)
{
     next if /$re/;
     print;
}
[download]

I'm not a huge fan of the 'next LABEL' command. It's too much like 'goto', which is one of those things that shouldn't be shown in public.

I don't think the purported similarity to goto is a good reason to not use Perl's loop control facilities. OK, the construct is abusable (what construct is not?), but when used appropriately I think that it clarifies things immensely.

FWIW the following article on Loop Exits and Structured Programming helped shaped my thinking on this.

In addition to the other advice, Perl makes possible neat idioms that I find are quite readable (adding ! to a regex match, while sometimes useful, can help you get lost in a sea of symbols):

while (<IN>) {
   # print if /$pattern/; # normal "grep"
   print unless /$pattern/; # grep -v
}
[download]

$_ is the "default" argument to print, as well as to the pattern match. The "grep -v" line is equivalent to:

print $_ unless $_ =~ /$pattern/;
[download]

HTH

perl -e 'print "How sweet does a rose smell? "; chomp ($n = <STDIN>); 
+$rose = "smells sweet to degree $n"; *other_name = *rose; print "$oth
+er_name\n"'
[download]

open(IN,$log) || die $!, "\n";
[download]

Second of all, you seem to using '$_' correctly so I wouldn't worry about that.

However in order to get a non-match you would need to use the expression:

if ( $_ !~ m/$i/ ) {
    print;
}
[download]

Update: I've been advised to not use the '|| die' notation and use instead 'or die'. As far as I can see this has to do with the trouble that could be caused by combining this notation with a function call that does not use parentheses.

The higher precedence of '||' causes Perl to see the call differently than if the 'or die' notation was used(when making a function call sans parentheses). Example:

open FH, "filename" or die $!;
#will read as its meant to: open(FH,"filename") or die $!;

open FH, "filename" || die $!;
#will read as: open FH,("filename" || die $!); which is not good since
+ the only time 
#this expression will be treated as false is in cases where filename i
+s an undefined expression(0,"",or undefined scalar)
#but unrecognized file names will not be evaluated as false so the die
+ will serve no purpose and the the script will continue to run
[download]

Amel - f.k.a. - kel

Just a brief addition to this. You'll get more information by leaving off the "\n".

open(IN,$log) || die $!, "\n";
#or
#open(IN,$log) || die "$!\n";
[download]

Gives the message:

No such file or directory

While

open(IN,$log) || die $!;

gives

No such file or directory at ./die line 5.

This behavior is documented in perldoc perlfunc die

After Compline,
Zaxo

Yet another brief addition: the message $! tells you the cause of the addition, but not the source. Zaxo already told you that leaving that newline out makes die tell the terminal which line of code generated that error.

However, that's not immediately informative. The command probably interpretets a variable to generate the syscall, so in general it's a good idea to provide that information :

open( INPUT, $filename ) or die "Could not open $filename: $!";
# or
rename( $old, $new ) or die "Could not rename $old to $new: $!";
[download]

As a third step, you can use Carp to print out the chain of callers. This is useful when your code is distributed over more than one file.

#!/usr/bin/perl -w
use strict;
my @avoid= map qr/\Q$_\E/i, qw(leroy brown);
my $log= "/home/psmith/logfile";
open( IN, "< $log" )  or  die "Can't read $log: $!\n";
my $line;
while( $line= <IN> ) {
    print $line   unless  grep $line =~ $_, @avoid;
}
[download]

If @avoid is quite large, then having grep always match against all of them might be worth avoiding. Maybe one day grep will be optimized for this case. (: Until then:

while( $line= <IN> ) {
    for(  @avoid  ) {
        if(  $line =~ $_  ) {
            print $line;
            last;
        }
    }
}
[download]

Update: except for that being backwards. Try:

while( $line= <IN> ) {
    for(  @avoid  ) {
        if(  $line =~ $_  ) {
            $line= "";
            last;
        }
    }
    print $line;
}
[download]

        - tye (but my friends call me "Tye")

Your second code prints if in @avoid. I hope it's Ironic(TM).