Ouch. You don't have to read all lines in at once first. This line is doing that since the angle bracket operator is invoked in array context:

my @file = <FH>;
[download]

local *FH;
open(FH, "/path/to/file") || die "Can't open file: $!";
while (<FH>)
{
    # line is in $_
    if ($_ eq $external_info)
    {
        print "great\!";
        last;
    }
}

close(FH);
[download]

I got what I needed -- thanks for the help!

You may be getting into swap by reading the whole file into an array. A while loop on the filehandle will read one line at a time into $_, keeping memory requirements to a minimum.

open my $fh, '<', '/path/to/file'
    or die $!;
while (<$fh>) {
    if ( $_ eq $external_info ) {
        print 'great!', $/;
        last;
    }
}
close $fh or die $!;
[download]

I converted to 3-arg open, and used a lexical file handle for that. You can convert back to suit previous versions of perl.

After Compline,
Zaxo

Using this code, you code might look like:

#   Tie the array @file to /path/to/file using a maximum of 1Mb of mem
+ory

tie my @file, 'Tie::File', '/path/to/file', 'memory' => 1_000_000 or
    die "Cannot open file - $!";

foreach my $line ( @file )
{
    #   ... Your code follows ...
}
[download]

This module is quite stable, despite the beta label given to it by its author, and works exceptionally well in a production environment (even under 5.005.03).

perl -le 'print+unpack("N",pack("B32","00000000000000000000001000110010"))'

while <FH>
{
   if ($_ eq $external_info) {
       print "great\!"; last;
   }
}
[download]

$/="$external_info";
open(FH, "/path/to/file") || die "Can't open file: $!";
while (<FH>) {
  if length($_) != (stat FH)[7]) {
    print "great\n";
    last;
  }  
}
[download]

-----------------------------------
--the good, the bad and the physi--
-----------------------------------

When you reference a file handle in list context (by assigning to an array), you read the whole file at once into memory. You can intead read the file line by line by using the file handel in scalar context (by assigning to a scalar). Instead of this...

open(FH, "/path/to/file") || die "Can't open file: $!";
my @file = <FH>;
close FH;
[download]

...try this...

open(FH, "/path/to/file") || die "Can't open file: $!";
foreach my $file (<FH>){
     if($file eq $external_info){
          print "great\!";
          last;
     }
}
close FH;
[download]

---
print map { my ($m)=1<<hex($_)&11?' ':'';
$m.=substr('AHJPacehklnorstu',hex($_),1) }
split //,'2fde0abe76c36c914586c';
[download]

You have to be careful here, because you are doing exactly the same thing. The foreach statement is also accessing <FB> in array context and is reading the whole file into an anonymous array and then iterating over it. You have to use a while loop for this to work correctly.

Try out the following bit of code to test this:

use Benchmark;

timethese(1, {
  'Trial1 While' => sub {
      open (FILE, "file2") or die "Can't open file:  $!\n";
      while (<FILE>) {
          last; # read one line and exit
      }
      close FILE;
  },
  'Trial2 Foreach' => sub {
      open (FILE, "file1") or die "Can't open file:  $!\n";
      foreach my $line (<FILE>) {
          last; # read one line and exit
      }
      close FILE;
  },
});
[download]

Make sure that file1 and file2 are identical (I used two files so that we know there is no caching going on), and that they are large text files. I got the following results with 2 50Meg files:

Benchmark: timing 1 iterations of Trial1 While, Trial2 Foreach...
Trial1 While:  0 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 CPU)
Trial2 Foreach: 17 wallclock secs (10.77 usr +  1.56 sys = 12.33 CPU) 
+@  0.08/s (n=1)
[download]

Your code still loads all the file first! The code (<FH>) generate first all the array that will be readed by foreach!

Take a look in this 2 test scripts. They show the file buffer position when you print each line:

  my $file = $0 ;
  
  open(FH, $file) ;
  foreach my $line (<FH>){
    my $tel = tell(FH) ;
    print "$tel>> $line" ;
  }
  close FH;
[download]

OK way:

  my $file = $0 ;
  
  open(FH, $file) ;
  while ( my $line = <FH> ) {
    my $tel = tell(FH) ;
    print "$tel>> $line" ;
  }
  close FH;
[download]

You can see that in the 1st way the buffer was always in the end, because it already have loaded all the file!

Graciliano M. P.
"The creativity is the expression of the liberty".

Let this note stand as a testimony to the dangers of cut-n-paste or cargo culting. In my code, I always use while when reading from files (honest!) but in my laziness, I copied and pasted from the base node into my reply without looking the code over well enough.

---
print map { my ($m)=1<<hex($_)&11?' ':'';
$m.=substr('AHJPacehklnorstu',hex($_),1) }
split //,'2fde0abe76c36c914586c';
[download]