Perl Dereference JSON Array: Extract Sent & DisplayText

In Perl, dereference a decoded JSON array reference like $data using @$data to loop through its hashrefs and pull out all sent timestamps, then dive into each nested data arrayref with @{ $item->{data} } to extract every displayText value—even when headline is missing. This explicit approach sidesteps those pesky reference errors that trip up beginners. You’ll collect everything cleanly with foreach loops or map for efficiency, handling optional keys safely.

Contents

• Understanding Perl References and JSON Data Structures
• Decoding JSON in Perl
• Dereferencing the Top-Level JSON Array
• Iterating Nested Data Arrays for displayText
• Efficient Extraction Using map
• Complete Working Code Example
• Sources
• Conclusion

Understanding Perl References and JSON Data Structures

Perl’s references can feel tricky at first—especially with JSON dumped into your lap. When you decode JSON, arrays become arrayrefs (like $data), objects turn into hashrefs, and nested bits stay nested. Your structure? A top-level arrayref holding hashrefs, each with a scalar sent and an arrayref data full of hashrefs that may or may not have headline.

Why dereference explicitly? The perlref documentation spells it out: no magic auto-unpacking in Perl. Use @$data for the array, $item->{sent} for hash access, and @{ $item->{data} } for the inner array. Skip this, and you’ll hit “Not a HASH reference” crashes.

Ever debug with Data::Dumper? Dump $data first to confirm the shape. Matches your JSON perfectly: two outer items, varying inner lengths.

Decoding JSON in Perl

Start right: grab a solid JSON module. JSON::PP ships with modern Perl—pure Perl, no C dependencies. For speed, prefer JSON::MaybeXS, which picks JSON::XS if installed.

use JSON::PP qw(decode_json); # Or JSON::MaybeXS
my $data = decode_json($json_text);

This gives $data as ARRAYREF. The JSON::PP docs note it handles UTF-8 cleanly; add utf8 => 1 if your text has accents. No more mangled strings.

Pro tip: Always use strict; use warnings; upfront. Catches deref slips early.

Dereferencing the Top-Level JSON Array

Here’s the perl dereference json array magic: @$data unpacks it into a real list for looping.

foreach my $item (@$data) {
 print $item->{sent} . "\n" if exists $item->{sent};
}

That spits out both “2026-01-16T17:00:00Z” lines. Why exists? Keys might vanish in real data—no autovivification surprises.

As perlmaven.com on dereferencing shows, arrow -> handles most access: $item->{data} yields the inner arrayref. Ready for nesting.

Iterating Nested Data Arrays for displayText

Nested JSON in Perl? Double-loop time. For each $item, deref its data:

foreach my $item (@$data) {
 foreach my $entry (@{ $item->{data} }) {
 print $entry->{displayText} . "\n" if exists $entry->{displayText};
 }
}

Boom—text2 through text10, skipping absent ones. Handles your uneven hashes (some have headline, some don’t). Rhetorical question: What if data is missing? Wrap in if (exists $item->{data} && ref $item->{data} eq 'ARRAY').

This perl nested json pattern scales; no recursion needed here.

Efficient Extraction Using map

Loops work, but map shines for collecting lists. Grab all sent timestamps:

my @sents = map { $_->{sent} // '' } @$data;

For every displayText? Chain maps—flatten the nests:

my @display_texts = map { $_->{displayText} // '' } map { @$_ } map { $_->{data} // [] } @$data;

First map pulls data arrayrefs (default empty), second flattens them (@$_), third extracts texts. perlref backs this: map loves derefs. Cleaner than nested pushes, and lazy.

Output? @sents has two timestamps; @display_texts grabs all ten texts.

Complete Working Code Example

Tie it together. Full script with your JSON hardcoded for testing:

#!/usr/bin/env perl
use strict;
use warnings;
use JSON::PP qw(decode_json);
use Data::Dumper;

my $json_text = q([
 {
 "sent": "2026-01-16T17:00:00Z",
 "data": [
 {"headline": "text1", "displayText": "text2"},
 {"displayText": "text3"},
 {"displayText": "text4"}
 ]
 },
 {
 "sent": "2026-01-16T17:00:00Z",
 "data": [
 {"headline": "text5", "displayText": "text6"},
 {"displayText": "text7"},
 {"displayText": "text8"},
 {"headline": "text9", "displayText": "text10"}
 ]
 }
]);

my $data = decode_json($json_text);

# Debug structure
print Dumper($data);

# All sent
print "Sent timestamps:\n";
foreach my $item (@$data) {
 print $item->{sent} . "\n" if exists $item->{sent};
}

print "\nDisplayTexts:\n";
# Nested loop version
foreach my $item (@$data) {
 next unless exists $item->{data};
 foreach my $entry (@{ $item->{data} }) {
 print $entry->{displayText} . "\n" if exists $entry->{displayText};
 }
}

# Map version for collection
my @sents = map { $_->{sent} // '' } @$data;
my @texts = map { $_->{displayText} // '' } map { @$_ } map { $_->{data} // [] } @$data;
print "\nCollected: ", scalar(@sents), " sents, ", scalar(@texts), " texts\n";

Runs clean, prints everything. Tweak for files or APIs. Pitfalls? Strict refs catch bad data; perlmaven.com/json warns of deep nesting limits.

Sources

1. perlref — Official guide to Perl references and explicit dereferencing: https://perldoc.perl.org/perlref
2. JSON::PP — Documentation for decoding JSON to Perl data structures: https://perldoc.perl.org/JSON::PP
3. Dereference hash/array — Practical examples of dereferencing nested hashes and arrays: https://perlmaven.com/dereference-hash-array
4. JSON in Perl — Handling nested JSON arrays and extraction techniques: https://perlmaven.com/json

Conclusion

Master perl dereference json array refs with @$data for top-level loops and @{ $item->{data} } for nests—print sent directly, grab displayText safely via exists. Maps make collection a breeze for bigger data. Test this script with your JSON; add Dumper if shapes shift. You’ll extract everything reliably, no crashes.