Building Nested Data Structures
Perl's native hashes and arrays can only hold scalars directly, but references let you store a pointer to an entire array or hash as a hash value, which is how nested structures are built. A hash of arrays (HoA) uses an arrayref as each value, so %department can map a team name to a list of employee names stored at that key. This is the foundation of representing trees, records, and JSON-like data entirely in native Perl syntax without extra modules.
Cricket analogy: A scorer's ledger keyed by team name, where each entry is not a single number but an array of every batsman's individual score for that innings, like Australia mapping to [Warner, Smith, Labuschagne] with their runs.
Hash of Arrays
To build a hash of arrays you either assign an arrayref directly with square brackets, like $hoa{fruits} = ['apple', 'banana'], or you push onto an auto-created array using the arrow-dereference push @{ $hoa{key} }, $value. Perl's autovivification means that referencing $hoa{key} in an array context automatically creates an empty arrayref there the first time you use it, so you rarely need to pre-initialize each key before pushing. Accessing an individual element requires dereferencing with an arrow, such as $hoa{fruits}[0], while looping over all values in a bucket uses @{ $hoa{fruits} }.
Cricket analogy: When a new wicket falls, the scorer just calls push @{ $innings{wickets} }, $batsman without first checking whether the wickets array already exists, exactly like autovivification silently creating the array on first use.
my %department;
push @{ $department{Engineering} }, 'Alice', 'Bob';
push @{ $department{Sales} }, 'Carol';
for my $team (sort keys %department) {
my @members = @{ $department{$team} };
print "$team: @members\n";
}
# Engineering: Alice Bob
# Sales: CarolArray of Hashes and Hash of Hashes
An array of hashes (AoH) is the natural shape for a list of records, such as rows returned from a CSV file or a database query, where each element is a hashref like { name => 'Alice', age => 30 }. You build it by pushing anonymous hashrefs onto an array: push @records, { name => $name, age => $age }. This is the idiom you will see constantly when processing tabular data, because it keeps each row's fields named rather than positional, which is far more readable than a plain array of arrays.
Cricket analogy: A match scorecard array where each element is a hashref like { batsman => 'Kohli', runs => 82, balls => 61 }, letting the scoring app push one structured record per dismissal rather than a bare list of numbers.
A hash of hashes (HoH) nests a hashref as a value instead of an array, which suits lookups by a unique key, such as %employees keyed by employee ID where each value is { name => ..., dept => ..., salary => ... }. You read a nested field with a chain of arrows, $employees{E123}{salary}, and Perl lets you drop the arrow between adjacent curly-brace or square-bracket subscripts, so $employees{E123}->{salary} and $employees{E123}{salary} are equivalent. This structure is ideal whenever you need O(1) lookup by ID rather than scanning a list, which an AoH would require.
Cricket analogy: A player registry hash keyed by jersey number where each value is a hashref { name => 'Bumrah', role => 'bowler', economy => 6.2 }, giving instant lookup instead of scanning a whole squad list.
Autovivification is powerful but can silently create unwanted empty hashrefs or arrayrefs. Merely checking if ($hash{key}{subkey}) creates $hash{key} as an empty hashref as a side effect. Use exists() carefully and consider Data::Dumper to inspect structures while debugging.
Traversing Nested Structures
Traversing nested structures means combining keys() or values() with dereferencing at each level, typically with nested for loops. For a hash of arrays, you loop over sorted keys() and then over the dereferenced array at each key; for a hash of hashes, you loop over the outer keys and then over the inner keys with keys %{ $hoh{$outer} }. Since Perl 5.24, postfix dereference syntax like $hoh{$outer}->%* or $hoa{$key}->@* is available and often reads more clearly than the older %{ $ref } sigil-wrapping style, especially for deeply nested chains.
Cricket analogy: A statistician loops through every team, then every player within that team's array, to compute the tournament's total run tally, the same two-level walk needed to sum values in a hash of arrays.
my %hoh = (
E123 => { name => 'Alice', dept => 'Eng', salary => 95000 },
E456 => { name => 'Bob', dept => 'Sales', salary => 72000 },
);
for my $id (sort keys %hoh) {
my $rec = $hoh{$id};
print "$id: $rec->{name} ($rec->{dept}) \$$rec->{salary}\n";
}
# Postfix deref (Perl 5.24+)
for my $id (sort keys %hoh) {
print "$id has ", scalar $hoh{$id}->%*, " fields\n";
}Always use 'strict' and 'warnings' when working with nested structures — a typo in a key name won't raise an error, it will silently autovivify a new branch full of undef values, which is one of the most common sources of hard-to-find bugs in Perl scripts.
- References let hash and array values point to other arrays or hashes, enabling arbitrary nesting.
- A hash of arrays (HoA) maps keys to arrayrefs; build it with push @{ $hoa{key} }, $value.
- An array of hashes (AoH) suits ordered records like CSV rows, each pushed as an anonymous hashref.
- A hash of hashes (HoH) gives O(1) lookup by a unique key, unlike scanning an AoH.
- Autovivification auto-creates intermediate structures on access, which is convenient but can mask typos.
- Traverse nested structures with paired keys()/dereference loops, or Perl 5.24+ postfix deref syntax like ->@* and ->%*.
- Always enable strict and warnings, since silent autovivification is a leading cause of nested-structure bugs.
Practice what you learned
1. What does the following code do if %hoa is initially empty? push @{ $hoa{fruit} }, 'apple';
2. Which structure is best suited for representing rows from a CSV file, where each row has named fields like name, age, and email?
3. Given my %hoh = ( E1 => { name => 'Alice' } );, which expression correctly retrieves 'Alice'?
4. Why is a hash of hashes (HoH) often preferred over an array of hashes (AoH) when records must be looked up by a unique identifier?
5. What is a key risk of autovivification mentioned as a common source of bugs?
Was this page helpful?
You May Also Like
Closures in Perl
Understand how Perl closures capture lexical variables to create private state, counters, and callback generators using anonymous subroutines.
Perl for System Administration
Use Perl's file, process, and text-processing tools to automate sysadmin tasks like file management, process control, and log analysis.
Perl and Databases (DBI)
Learn how Perl's DBI module provides a uniform interface for connecting to databases, running parameterized queries, and managing transactions safely.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics