Question

I have a problem accessing to data, described in the title of the question.
The structure of the data is the following:

my @structure = (
  {
   "Name" => "Test",
   "Param1" => 1,
   "Data1" => \@test1,
   "Data2" => [\@test3],
   "Data3" => [\@test1, \@test2],    
  },
  ...
);

And I need to access the 1st (#0) element of the array @test3.
I tried something like this:

my @array   = @{$_->{'Data2'}}[0];
print $array[0];

But then I get a reference to the array (ARRAY(0x239c3c)) instead of the required meaning. I feel that there’s something global that I don’t understand here.
Couldn’t you explain how and why I should address to the required meaning?
Thanks a lot.

Answer 1

You can use the syntactic sugar of -> to get the reference you want. It’s much cleaner than using parentheses.

And I need to access the 1st (#0) element of the array @test3

Okay, in your structure, it’d be:

my $element = $structure[0]->{Data2}->[0]->[0];

This is equivalent, but harder to read:

my $element = ${${${$structure[0]}{Data2}}[0]}[0];

And, in this particular case, you can eliminate the syntactic sugar ->:

my $element = $structure[0]{Data2}[0][0];

However, I don’t know if that makes it easier to read, and there are cases where the default way of parsing that might not do exactly what you want. I tend to squeeze everything together when I’m referring to an array of arrays, but that’s it:

my $element = $array[0][3];     #This is okay
my $element = $array[0]->[3];   #Same as above, but with -> syntax

Otherwise, I’ll use the syntactic sweetener of ->.

Here’s an explanation of the syntax:

• $structure[0] is a reference to the first item of your @structure array. This contains a reference to a hash.
• $structure[0]->{Data2} is a reference to the hash element Data2 in the first item in your @structure array. This is a reference to an array.
• $structure[0]->{Data2}->[0] is a reference to the first array reference in the Data2 hash element in the first element (0) of your @structure array. This is your @test3 array.
• $structure[0]->{Data2}->[0]->[0] is the first element of the @test3 array.

I also recommend you use the Data::Dumper module as you write your code. It’ll help you see what structure you’re referencing and help point out any errors in the levels. For example:

use Data::Dumper;

print $structure[0]->{Data2}->[0] . "\n";

Will show you that this is a reference to another array layer.

print "$structure[0]\n";

Will show you this is a reference to a hash where each item contains references to arrays of arrays.

---

Whenever you use these highly complex structures, it screams for using object oriented Perl coding. I’m not 100% sure what you’re doing, so I can’t help you with your objects, but highly complex structures tend to break and are almost impossible to maintain.

For example, we now do this:

use strict;
use warnings;

my $Foo = "bar";
print "Foo = $foo\n";

This quickly detects that I misspelled my variable name by doing $foo instead of $Foo. This was a big improvement over older versions of Perl where this type of error checking couldn’t be done.

However, now look at this:

use strict;
use warnings;

my %hash;
$hash{Foo} = "bar";
print "Foo = $hash{foo}\n";

We’ve lost the compilation error checking. %hash is a legitimate variable, but $hash{Foo} is defined and not $hash{foo}. In this case, use strict does nothing for you.

Using object oriented Perl returns this error check:

use strict;
use warnings;
use Object::Foo;

my $hash = Object::Foo->new;
$hash->Foo(bar);
print "Foo = " . $hash->foo . "\n";

Whoops! The method should be Foo and not foo. However, Perl is able to detect that the method foo doesn’t exist and will once again generate an error on compile.

In the above case, it’s pretty straight forward, but you’re dealing with an array of hashes of arrays of arrays. The possibility of an error is multiplied by 100 with each reference access. And, because you have to spell out these references over and over in your code, an error can be located in dozens of different places. Even if you could code this initially and then comment the entire structure in your code, it’ll be impossible to maintain this when you come back to this after three months.

Take a look at Perldoc’s Tutorials and go through the ones for object oriented programming.