No output when using File::Find module - perl

Question

I would like to count the total number of files whose modify_time is between $atime and $btime. Here is part of my code, but it doesn't return anything. What is wrong?
sub mtime_between {
my $mtime=0;
my $counts=0;
$mtime = (stat $File::Find::name)[9] if -f $File::Find::name;
if ($mtime > $atime and $mtime < $btime) {
return sub { print ++$counts,"$File::Find::name\n"};
}
When i call the subroutine, I get nothing.
find(\&mtime_between,"/usr");

Answer 1

You should not be returning a function.
Check File::Find documentation.
find() does a depth-first search over the given #directories in the order they are given. For each file or directory found, it calls the &wanted subroutine.
In the wanted function you should do the things you want to do directly. To return a function reference will not work and this is why you are having problems.
So you actually want something more like:
#!/usr/bin/env perl
use strict;
use warnings;
use feature qw{say};
use File::Find;
use Data::Dumper;
my ($atime, $btime) = (1461220840, 1561220844);
sub findFilesEditedBetweenTimestamps {
my ($atime, $btime, $path) = #_;
my $count = 0;
my #files = ();
my $mtime_between = sub {
my $mtime = 0;
$mtime = (stat $File::Find::name)[9] if -f $File::Find::name;
if ($mtime > $atime and $mtime < $btime) {
push #files, $File::Find::name;
$count++;
}
return;
};
find ($mtime_between, $path);
say "Found a total of $count files";
say "Files:";
print Dumper(#files);
}
findFilesEditedBetweenTimestamps($atime, $btime, "./");
I get:
Found a total of 2 files
Files:
$VAR1 = './test.txt';
$VAR2 = './test.pl';

Answer 2

As has been said, the value returned by the wanted subroutine is ignored. Returning a callback from a callback may be a step too far for some!
This may be of interest. I've used the File::stat module to make extraction of the modification time more readable, and Time::Piece, so that $atime and $btime can be expressed in readable strings instead of epoch values
There's no need to write a separate subroutine for the wanted function unless you prefer -- you can just use an anonymous subroutine in the find call. And it's easiest to simply return from the wanted subroutine if the node isn't a file
#!/usr/bin/env perl
use strict;
use warnings 'all';
use File::Find;
use File::stat;
use Time::Piece;
sub count_files_between_times {
my ($from, $to, $path) = #_;
my $count = 0;
find(sub {
my $st = stat($_) or die $!;
return unless -f $st;
my $mtime = $st->mtime;
++$count if $mtime >= $fromand $mtime <= $to;
}, $path);
print "Found a total of $count files\n";
}
my ($from, $to) = map {
Time::Piece->strptime($_, '%Y-%m-%dT%H:%M:%S')->epoch;
} '2016-04-19T00:00:00', '2019-04-22T00:00:00';
count_files_between_times($from, $to, '/usr');
Update
Some people prefer the File::Find::Rule module. Personally I dislike it intensely, and having looked at the source code I am very wary of it, but it certainly makes this process more concise
Note that File::Find::Rule is layered on top of File::Find, which does the heavy-lifting for it. So it is essentially a different way of writing the wanted subroutine
use File::Find::Rule ();
sub count_files_between_times {
my ($from, $to, $path) = #_;
my #files = File::Find::Rule->file->mtime(">= $from")->mtime("<= $to")->in($path);
printf "Found a total of %d files\n", scalar #files;
}
or if you prefer you can add the restrictions one statement at a time
use File::Find::Rule ();
sub count_files_between_times {
my ($from, $to, $path) = #_;
my $rule = File::Find::Rule->new;
$rule->file;
$rule->mtime(">= $from");
$rule->mtime("<= $to");
my #files = $rule->in($path);
printf "Found a total of %d files\n", scalar #files;
}
Both of these alternative subroutines produce identical results to that of the original above