use warnings;
use strict;

my %hash_of_hash_of_arrays = (
          'key' => {
                     'innerkey2' => [
                                      'here'
                                    ],
                     'innerkey3' => [
                                      'there'
                                    ],
                     'innerkey1' => [
                                      'hello',
                                      'world'
                                    ]
                   }
        );

foreach my $outerkey (keys %hash_of_hash_of_arrays) {
  print "'$outerkey'\n";

  foreach my $innerkey (keys %{ $hash_of_hash_of_arrays{$outerkey} }) 
+{  # <---- added curlies
    print "$innerkey\n";

    foreach my $array_item (@{ $hash_of_hash_of_arrays{$outerkey}{$inn
+erkey} })
    {
      print "array item: $array_item\n";
    }
  }
}

__END__

'key'
innerkey2
array item: here
innerkey1
array item: hello
array item: world
innerkey3
array item: there
[download]

For output order predictability, you can sort keys.

Hashes and array elements are scalar values so can only hold references to nested hashes or arrays. Therefore hash_of_hash_of_arrays{$outerkey} is a reference to a hash. To get the hash you need for keys you need to dereference it using %{}: %{$hash_of_hash_of_arrays{$outerkey}}.

Note that $, % and @ don't tell you what type variables are, they tell you what type of thing an expression returns. So $ref returns a scalar which may be a reference to an array or a hash. @$ref and @{$ref} return arrays (they are equivalent) by dereferencing $ref. The {} version is much clearer (and often required) when the expression used to get the reference is complicated.

Perl's own documentation on this subject is very good. (Refer to the section "Using References" of perldoc perlref

Grandfather is recommending rule 2 because it always works. The other rules are essentially "short cuts" which apply in special cases.
Bill

From the docs:

Starting with Perl 5.14, keys can take a scalar EXPR, which must contain a reference to an unblessed hash or array. The argument will be dereferenced automatically. This aspect of keys is considered highly experimental. The exact behaviour may change in a future version of Perl.

1. for (keys $hashref) { ... }
2. for (keys $obj->get_arrayref) { ... }