Issues with function calls for search routine

Question

My aim is to have multiple searches of specific files recursively. So I have these files:

/dir/here/tmp1/recursive/foo2013.log
/dir/here/tmp1/recursive/foo2014.log
/dir/here/tmp2/recursive/foo2013.log
/dir/here/tmp2/recursive/foo2014.log

where the 2013 and 2014 says in which year the files got modified lastly.

I then want to find the more up to date files (foo2014.log) for each directory tree (tmp1 and tmp2 likewise).

Referring to this answer I have the following code in script.pl:

#!/usr/bin/perl
use strict;
use warnings;
use File::Find;

func("tmp1");
print "===\n";
func("tmp2");

sub func{
    my $varName = shift;
    my %times;
    find(\&upToDateFiles, "/dir/here");

    for my $dir (keys %times) {
        if ($times{$dir}{file} =~ m{$varName}){
            print $times{$dir}{file}, "\n";
            # do stuff here
        }
    }

    sub upToDateFiles {
        return unless (-f && /^foo/);
        my $mod = -M $_;
        if (!defined($times{$File::Find::dir})
         or $mod < $times{$File::Find::dir}{mod})
        {
            $times{$File::Find::dir}{mod} = $mod;
            $times{$File::Find::dir}{file} = $File::Find::name;
        }
    }
}

which will give me this output:

Variable "%times" will not stay shared at ./script.pl line 25.
/dir/here/tmp1/recursive/foo2014.log
===

I have three questions:

1. Why isn't the second call of the function func working like the first one? Variables are just defined in the scope of the function so why am I getting interferences?

2. Why do I get the notification for variable %times and how can I get rid of it?

3. If I define the function upToDateFiles outside of func I am getting this error: Execution of ./script.pl aborted due to compilation errors. I think this is because the variables aren't defined outside of func. Is it possible to change this and still get the desired output?

Answer 1

For starters - embedding a sub within another sub is rather nasty. If you use diagnostics; you'll get:

(W closure) An inner (nested) named subroutine is referencing a
lexical variable defined in an outer named subroutine.

When the inner subroutine is called, it will see the value of
the outer subroutine's variable as it was before and during the *first*
call to the outer subroutine; in this case, after the first call to the
outer subroutine is complete, the inner and outer subroutines will no
longer share a common value for the variable.  In other words, the
variable will no longer be shared.

This problem can usually be solved by making the inner subroutine
anonymous, using the sub {} syntax.  When inner anonymous subs that
reference variables in outer subroutines are created, they
are automatically rebound to the current values of such variables.

Which is directly relevant to the problem you're having. Try to avoid nesting your subs, and you won't have this problem. It certainly looks like you're trying to be far more complicated than you need to. Have you considered something like:

#!/usr/bin/perl
use strict;
use warnings;
use diagnostics;

use File::Find;

my %filenames;

sub compare_tree {
    return unless -f && m/^foo/;

    my $mtime = -M $File::Find::name;

    if ( !$filenames{$_} || $mtime < $filenames{$_}{mtime} ) {
        $filenames{$_} = {
            newest => $File::Find::name,
            mtime  => $mtime,
        };
    }
}

find( \&compare_tree, "/dir/here" );

foreach my $filename ( keys %filenames ) {
    print "$filename has newest version path of:", $filenames{$filename}{newest}, "\n";
    print "$filename has newest mtime of:",        $filenames{$filename}{mtime},  "\n";
}

I'd also note - you seem to be using $File::Find::dir - this looks wrong to me, based on what you describe you're doing. Likewise - you're running find twice on the same directory structure, which is not a very efficient approach - very big finds are expensive operations, so doubling the work needed isn't good.

Edit: Caught out by forgetting that -M was: -M Script start time minus file modification time, in days.. So 'newer' files are the lower number, not the higher. (So have amended above accordingly).