Here's my go.

while( <F>){

    for $hit ( /matchPattern/gi) {

        print "PAGE ->\t$name\ndata ->",
            /(patternOne)/gi or /(patternTwo)/gi
            ? "\t\t$1\nMATCHED - >\t$hit\n"
            : "TEXT INFO HERE.\n";
            
        push (@files, $name);
        $ct++
    }
}
close F;
[download]

Just one correction and one nag:

The or has too low precedence and should be replaced with ||.

$_ isn't localized. I know, I'm cranky about this, but I actually find it worth pointing it out all the time. :-) (Take a look at Localizing $_ and while (<FH>) { ... }. (Is really: "Re: Re4: matching every occurrence of a regex") for a more elaborate view.)

ihb

++ Well picked up on the or thing. I really should have added an "untested" rider to that code. It was purely an editor exercise and completely untested. I should have spotted the error, but I tend to use or rather than || as a matter of course and let the compiler inform me when I need to change it. Hey, that's what compilers are good at :)

With respect to the non-localisation of $_ in while loops. Your right to point it out. It's one of those things that I take on a case by case basis, but it is so useful, that I wouldn't want to never use it.

Does anyone know if there is a good reason why $_ isn't localised in while loops as it is in for loops?

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"When I'm working on a problem, I never think about beauty. I think only how to solve the problem. But when I have finished, if the solution is not beautiful, I know it is wrong." -Richard Buckminster Fuller

Thanks for ALL your replies!!! I now see it looking better.

while($line = <F>) {
    for my $hit ($line =~ /matchPattern/gi) {
        $ct++;
        push @files, $name;
        print "PAGE ->\t$name\ndata ->";

        if( $line =~ /(patternOne)/i ) {
            print "\t\t$1\nMATCHED - >\t$hit\n";
        } 
        elsif( $line =~ /(patternTwo)/i ) {
            print "\t\t$1\nMATCHED - >\t$hit\n";
        } 
        else {
            print " TEXT INFO HERE.\n";
        }        
    }   
}
[download]

-sauoq
"My two cents aren't worth a dime.";

Since you're printing more or less the same thing, see if you can combine the patterns you're matching against thusly:

while($line = <F>) {
    for my $hit ($line =~ /matchPattern/gi) {
        $ct++;
        push @files, $name;
        print "PAGE ->\t$name\ndata ->";

        if( $line =~ /(patternOne|patternTwo)/i ) {
            print "\t\t$1\nMATCHED - >\t$hit\n";
        } 
        else {
            print " TEXT INFO HERE.\n";
        }        
    }   
}
[download]

In general, it's more efficient to elevate the "ors" out of the pattern. In other words,

$line =~ /pat1/ or $line =~ /pat2/
[download]

is usually better than a single more complex regular expression.

-sauoq
"My two cents aren't worth a dime.";

my %match = (
   'pattern_one' => 1,
   'pattern_two' => 1,
);

while (<F>) {
   next unless ( m/(match_pattern)/ );

   print "PAGE ->\t$name\ndata ->";

   print $match{$1} ? "\t\t$1\nMatched ->\t$hit\n"
                    : " TEXT INFO HERE\n";
   push(@files, $name);
   $ct++;
}
close(F);
[download]

In this case the %match is a little useless, as your blocks aren't really doing anything all that different aside from what to print. You are also using variables in the block that aren't being created in the block so its difficult to grasp exactly what you are trying to shorten. In a more complex case, the value of $match{pattern} could be a code ref, or any other data structure which could shorten the main loop a touch.. Something like

my %match = (
   'pattern_one' => [\&sub_one, $results_one],
   'pattern_two' => [\&sub_two, $results_two],
);

while (<F>) {
   chomp;
   next unless ( m/(match_pattern)/ );

   unless ( $match{$1} ) {
      #something basic goes here
      next;
   }

# get the right function from our dispatch table
   ($func, $results) = [ $match{$1} ];

# now call it, pass it the text to process, and store the 
# results.
   $results = &$func($1);

} # END while <F>
close(F);
[download]

In my own code, I tend to either make $results either an array or hash reference, depending on the situation, and the call may be altered to be say push(@$results, &$func($1)); or some such.

HTH, regards

use perl;

my @patterns = (qr/(patternOne)/, qr/(patternTwo)/);
my $match;
print "PAGE ->\t$name\ndata ->";
for my $pat (@patterns) {
 if ($line =~ $pat and not $match++) {
  print "\t\t$1\nMATCHED - >\t$hit\n";
  push (@files, $name);
  $ct++;
  last;
 }
}
$print " TEXT INFO HERE.\n" if not $match;
[download]

Mmmmm refactoring. See also Once and Only Once.

Update: Fixed bugs pointed out by Re: Re: Shorten script. Big error, thanks for the heads-up. Hrm. Could probably still be cleaned up more.. let's call that an exercise to the reader..

Update: stole idea (break up prints) from sauoq's response. If you are unlikely to add more conditions, his way is probably better. Mine is pretty easy to add new conditions to though, just add to the @patterns = (...);

That dosen't do the same thing as the original code did. It would only use the first matching pattern and then stop, and it also had an action for when none of them matched.

There has been other good replies already, so I'll leave it with that. Except there is (at least) one thing that everyone seem to have overlooked.

The $ct variable is increased for every hit, or more interestingly, for each time @files is increased. So that can be replaced by

  $ct -= @files;
  while (my $line = <F>) { ... } # Old code without $ct
  $ct += @files;
[download]