$ cat `find . -type f` | wc -l

It'll choke if you have too many files in the directory in question, as
there are limits to how long the argument list can be in the shell, but
provided that you don't exceed that limit, this will get you a quick and
dirty answer to your question.

Otherwise, you'll need to build up a list with File::Find or similar
module, then work through the list looking for newline chatacters for
each file in that list. It should get the same result as above, but will
take more hand-coding to get to the final result, and it shouldn't hit
the limitation of too many files that the shell approach will have.

--
Chris Devers

    A lot depends on your idea of "best". It might be that the
best way is to hand the project off to someone else and reap the
benefits of their skills. In fact, many very rich people say this
is the best way to do just about anything. So what do you mean by
"best"?

    One way to tackle this problem is to figure out how to find
the number of new lines in any file. Since any file may be very
large, assume at least one file cannot be loaded into memory.
Now take that solution and File::Find to apply it to many files.

HTH,

Charles K. Clarkson
--
Mobile Homes Specialist
254 968-8328

    Please do not provide outdated, buggy solutions to a beginners
list. We are trying to do much more than just solve problems. We
are (hopefully) fostering good programming skills first and good
solutions second. Your solution not only didn't run, it provided
several excellent reasons why simple approaches do not always work
across many OS platforms.

See:
perldoc perlvar (search for $|)
perldoc FileHandle

--

Just my 0.00000002 million dollars worth,
    --- Shawn

#!/usr/bin/perl

use File::Find;
my $totalLines;
     find(\&wanted, '@directories');
     sub wanted {
         unless ($_=~m/.html|.mas|.pl|.txt$/i) {return 0;} #filter the kinds  
of files you want
         open FILE, "<$File::Find::name";
         print "$_: ";
        my @lines=<FILE>;
        print "$#lines\n";
            $totalLines+=$#lines; #wanted's value is ignored so we have to  
do this here.
        return;}
            print "$totalLines\n";

This only limits me by the size of the file, or no?

--

Just my 0.00000002 million dollars worth,
    --- Shawn

Use a module when doing so is beneficial. Many
modules are worth using. Most are not.

Research and read about Perl's  $.   default variable.

Below you will find an exceptionally efficient method
and an easy-to-configure method. This method will
present an alternative for you to study.

Purl Gurl

#!perl

$internal_path = "c:/your/path/directory";  # your path here

chdir($internal_path);

@Directory_Parent = $internal_path;

while (@Directory_Parent)
 {
  $directory = shift (@Directory_Parent);
  opendir(DIR, $directory) || next;
  while (defined($child = readdir(DIR)))
   {
    if (-d "$directory/$child" && $child ne "." && $child ne "..")
     { push(@Directory_Parent, "$directory/$child"); }

    if (-f "$directory/$child")
     { push (@File_List, "$directory/$child"); }
   }
  closedir(DIR);
 }

for $file (@File_List)
 {
  open (COUNT, $file) || die $!;
  while (<COUNT>)
   { $total_lines += $.; }
  close (COUNT);
 }

print "Total Lines: $total_lines";

# optional

use warnings;
use strict;

        return unless /\.(?:html|mas|pl|txt)$/i;

        $totalLines += @lines;

But you don't really need to store all the lines in an array, you can do it
more simply as:

        () = <FILE>;
        print "$.\n";
        $totalLines += $.;

Or use the example in the FAQ:

perldoc -q "How do I count the number of lines in a file"

Hi,

In addition to John W. Krahn's good advices:

   open (FILE, '<', $File::Find::name)
      or die "couldn't open $File::Find::name: $!";

        close FILE or die "couldn't close $File::Find::name: $!";

sub wanted {

    ...

    () = <FILE>;
    print "$.\n";
    $totalLines += $.;
    }
print "$totalLines\n";

Produces an incorrect value for $totalLines unless you close the filehandle
but if you don't close the filehandle then you can do this:

sub wanted {

    ...

    () = <FILE>;
    }
print "$.\n";

My thought was: When I always close filehandles, I don't have to think about
closing or not closing them (comparable to give always signs when driving,
even if nobody else is on the road).

For exemple perldoc -f open states:

   "[...] You don't have to close FILEHANDLE if you are immediately
    going to do another "open" on it [...]"

In a normal case, there is one point at which any filehandle is not reopened:
After the last reopening. So this case would have to be checked in a loop
(pseudocode: close FH if finished reopening)?