First thought on reading this is "wow, you're doing a lot that you don't have to." There are a few stylistic issues that boil down to making your code a little more readable. But a big thing might be to forego the idea of using an array of arrays. You're dealing with filenames, which, in a given directory, must be unique. You want to record a certain bit of information about each file, so why not have the keys be the filenames and the values be those bits of information?

For example, to get the mtimes on all your files, which is the only bit from the stat call you want to keep, you can do the following:

my %filenames =();
foreach( <post*.*> ) {
    $filenames{$_} = -M $_;
}
[download]

my @sorted_keys = sort { $filenames{$a} <=> $filenames{$b}} keys %file
+names;
[download]

Now, for your original question (finally!). I think what's going on is a scoping issue. You define @fileanddate outside the loop, and put a reference to it into the array you're returning each time you process a file. But there is only one @fileanddate, so you're filling up your returned array with a bunch of references to that same thing. A better approach, keeping your current code for the most part, would have your loop that constructs the array look like this:

foreach my $filename ( @filenames ) {
    # create an ANONYMOUS array (basically a reference to an array)
    my $record = [ $filename, -M $filename ];
    push @filesanddates, $record;
}
[download]

HTH!

If not P, what? Q maybe?
"Sidney Morgenbesser"

I am trying to build an array of arrays in one function, pass it out in to the main scope of the script, then back into another function to print it's contents.

sub ret_arr   { return( ["foo"],["bar"],["baz"] ) }
sub print_arr { print @$_ for @_ }

my @arr = ret_arr();
print_arr(@arr);

__output__

foobarbaz
[download]

use IO::Dir;
sub files_by_mtime {
  my $d = IO::Dir->new($_[0]) or die "ack: $!";
  return map  { $_->[0] }
         sort { $a->[1] <=> $b->[1] }
         map  { [ $_, (stat "$_[0]/$_")[9] ] }
         grep { /^post.*\../ } $d->read;
}
[download]

_________
broquaint

my @fileanddate;
[download]

Then, in the foreach loop, you do:

@fileanddate = ($filename, $mtime);
$filesanddates[$filecounter] = \@fileanddate;
[download]

That's your error. All of the references you push onto @filesanddates point to the same array, @fileanddate. Hence, all of these point to the same piece of data. This piece of data is the one you last put into it - the last set of (filename, mtime).

To solve this, just make sure that the reference you push onto @filesanddates is to something that is scoped locally to the foreach block. For example:

foreach my $filename (@filenames) {
  my $mtime=(stat ($filename))[9];
  my @fileanddate=($filename, $mtime);
  # Note lexical scoping of @fileanddate
  push @filesanddates, \@fileanddate;
}
[download]

foreach my $filename (@filenames) {
  push @filesanddates, [ ( $filename, (stat ($filename))[9] ) ];
}
[download]

For more information on scoping, have a look at this tutorial.

CU
Robartes-

Thank you thank you thank you all!! I can't believe the speed and quality of these responses. This is truely an enlightened forum :)

I followed Robartes suggestion of lexical scoping and it works now. This seemed to be the simplest modification to my existing code and something I understood right away. However, I shall certainly read through all the excellent suggestions and try to understand and incorporate them soon.

When you're passing arrays and hashes into and out of subs, it's (normally) necessary to pass a reference to the array, rather than the array itself.

If you don't pass a reference, the array is flattened, and passed out as a simple list - not something you want in this case.

You can correct this by having the GetLogFilesAndDatesIntoArray sub return a reference to the AoA, rather than trying to flatten the AoA and then return it. This is easy to do - just change the return to return \@filesanddates;.

Once you have the sub returning a reference, you should assign it to a scalar variable, rather than an array (a reference is always a scalar, regardless of what it refers to), and you can then use this variable to pass the array into the ExtractData sub - like this:

# note: $datalist now, it's a reference
$datalist = GetLogFilesAndDatesIntoArray($logdirectory);
ExtractData($datalist); # passes the reference into the sub
[download]

Finally, once you have the reference going into the ExtractData sub, you can deference it to retrieve the original array like this:

my $_filesanddates = shift;
@filesanddates = @$_filesanddates; # dereferences the reference
[download]

There's a whole load of stuff on references and subroutines in perlsub and perlref.

Update: Thanks to broquaint for pointing out that I'm talking absolute rubbish .. oh well, eh. References are still a Good Thing in my book, but I guess that's a preference now, rather than a requirement...

Hope that helps a little ...
-- Foxcub
A friend is someone who can see straight through you, yet still enjoy the view. (Anon)
All code is untested unless explicitly stated otherwise.

If you don't pass a reference, the array is flattened, and passed out as a simple list - not something you want in this case.

Er, wha? This is a perfectly valid case to pass a list back and forth. Since the code is only dealing with a single array this is not an issue, it would be an issue however if multiple arrays were being passed about e.g

sub f { print "got: ", @_, $/ }

my @a = qw( one two three );
my @b = qw( four five six );

## @a & @b will be flattened into a single list
f(@a, @b);

## pass references to keep array integrity
f(\@a, \@b);

## only @a is passed, so only @a is received
f(@a);

__output__

got: onetwothreefourfivesix
got: ARRAY(0x8107e50)ARRAY(0x8107f34)
got: onetwothree
[download]


HTH

_________
broquaint

Eh?

I was always told that "complex" structures (anything other than a "simple" array or hash - and the OP is talking about an AoA) got flattened, and that its integrity wasn't necessarily preserved when it was passed into and out of a sub.

I'm quite happy to be wrong, though .. that's been a pet peeve of mine with Perl for *ages* ... *grin* ..

My thinking this (probably) comes from perlsub ..

Perl sees all arguments as one big, long, flat parameter list in @_. Like the flattened incoming parameter list, the return list is also flattened on return.

I read this as saying that if I have a crazily bizarre structure, such as an AoA or AoH or whatever, its integrity and structure will not necessarily be preserved - epecially not if it becomes a simple list of scalars.

Can anyone clarify this? I'm gonna play with some code, see what happens ..

Update: Ok, so code playing proves I'm completely wrong ... all kudos to broquaint - I've learnt something completely new today .. and got rid of a pet hate :)

-- Foxcub
A friend is someone who can see straight through you, yet still enjoy the view. (Anon)

$filesanddates[$filecounter] = \@fileanddate;
[download]

$logfilename = $filesanddates->[$listcount][0];
[download]

$filesanddates[$filecounter] = \@fileanddate;
[download]

       !/usr/bin/perl -w
       
       use strict;
       
       # You can use this module for dumping your data.
       use Data::Dumper; 
       
       # Function which forms an files array 
       sub one {
          my $dir = shift; # Dir name

          opendir(DIR, $dir) or die "Can't open $dir: $!";
          my @files = grep { !(/^\./) && /^post/ && -f } readdir(DIR);
          closedir(DIR);
                
          my $res; # Array reference which will consist results
      
          @$res = map { [$_, (stat($_))[9]] } @files;              
          
          return $res;
      }

      # Function which processes result array 
      sub two {
          my $array = shift;
      
          for(@$array) {
              print $_->[0] .': '.$_->[1]."\n";
              
              <do something> ...
          }
      }
      
      # Call our functions 
      two(one('/var/logs'));
[download]

========================
{ firstname => 'Michael',
quote => 'Mice were crying and stinging but went on nibbling the cactus', }

Just

use Data::Dumper;
[download]

and then pass your data structure to it:

print Dumper( \@my_complicated_array );
[download]

and you'll get a nicely formatted view of your data structure on screen or wherever STDOUT is pointing. One caveat: if your structure is too large it can take a long time to dump. Regards, Cat