Decoding and using JSON data in Perl

Beginner's answer to beginner :) Sure not as profesional as should be, but maybe helps you.

use strict;    #use this all times
use warnings;  #this too - helps a lot!
use JSON;

my $json_str = '    { "items" : [ 1, 2, 3, 4 ] }    ';
my $content = decode_json($json_str);

You wrote:

My guess tells me that, once decoded, the object will be a hash with one element that has the key items and an array reference as the value.

Yes, it is a hash, but the the decode_json returns a reference, in this case, the reference to hash. (from the docs)

expects an UTF-8 (binary) string and tries to parse that as an UTF-8 encoded JSON text, returning the resulting reference.

In the line

my $content = decode_json($json_str);

you assigning to an SCALAR variable (not to hash).

Because you know: it is a reference, you can do the next:

printf "reftype:%s\n", ref($content);
#print: reftype:HASH       ^   
           #therefore the  +------- is a SCALAR value containing a reference to hash

It is a hashref - you can dump all keys

print "key: $_\n" for keys %{$content}; #or in short %$content
#prints: key: items

also you can assing the value of the "items" (arrayref) to an scalar variable

my $aref = $content->{items};   #$hashref->{key}
#or
#my $aref = ${$content}{items}; #$hash{key}

but NOT

#my $aref = $content{items};    #throws error if "use strict;"
#Global symbol "%content" requires explicit package name at script.pl line 20.

The $content{item} is requesting a value from the hash %content and you never defined/assigned such variable. the $content is an scalar variable not hash variable %content.

{
    #in perl 5.20 you can also
    use 5.020;
    use experimental 'postderef';
    print "key-postderef: $_\n" for keys $content->%*;
}

Now step deeper - to the arrayref - again you can print out the reference type

printf "reftype:%s\n", ref($aref);
#reftype:ARRAY

print all elements of array

print "arr-item: $_\n" for @{$aref};

but again NOT

#print "$_\n" for @aref;
#dies: Global symbol "@aref" requires explicit package name at script.pl line 37.

{
    #in perl 5.20 you can also
    use 5.020;
    use experimental 'postderef';
    print "aref-postderef: $_\n" for $aref->@*;
}

Here is an simple rule:

my @arr;               #array variable
my $arr_ref = \@arr;   #scalar - containing a reference to @arr

@{$arr_ref} is the same as @arr 
 ^^^^^^^^^^ - array reference in curly brackets

If you have an $arrayref - use the @{$array_ref} everywhere you want use the array.

my %hash;              #hash variable
my $hash_ref = \%hash; #scalar - containing a reference to %hash

%{$hash_ref} is the same as %hash
 ^^^^^^^^^^^ - hash reference in curly brackets

If you have an $hash_ref - use the %{$hash_ref} everywhere you want use the hash.

For the whole structure, the following

say $content->{items}->[0];
say $content->{items}[0];
say ${$content}{items}->[0];
say ${$content}{items}[0];
say ${$content->{items}}[0];
say ${${$content}{items}}[0];

prints the same value 1.

$content is a hash reference, so you always need to use an arrow to access its contents. $content{items} would refer to a %content hash, which you don't have. That's where you're getting that "use of uninitialized value" error from.

I actually asked a similar question here

The answer:

In Perl, a function can only really return a scalar or a list.

Since hashes can be initialized or assigned from lists (e.g. %foo = (a => 1, b => 2)), I guess you're asking why json_decode returns something like { a => 1, b => 2 } (a reference to an anonymous hash) rather than (a => 1, b => 2) (a list that can be copied into a hash).

I can think of a few good reasons for this:

in Perl, an array or hash always contains scalars. So in something like { "a": { "b": 3 } }, the { "b": 3 } part has to be a scalar; and for consistency, it makes sense for the whole thing to be a scalar in the same way.

if the hash is quite large (many keys at top-level), it's pointless and expensive to iterate over all the elements to convert it into a list, and then build a new hash from that list. in JSON, the top-level element can be either an object (= Perl hash) or an array (= Perl array). If json_decode returned a list in the former case, it's not clear what it would return in the latter case. After decoding the JSON string, how could you examine the result to know what to do with it? (And it wouldn't be safe to write %foo = json_decode(...) unless you already knew that you had a hash.) So json_decode's behavior works better for any general-purpose library code that has to use it without already knowing very much about the data it's working with.

I have to wonder exactly what you passed as an array to json_decode, because my results differ from yours.

#!/usr/bin/perl

use JSON qw (decode_json);
use Data::Dumper;
my $json = '["1", "2", "3", "4"]';

my $fromJSON = decode_json($json);

print Dumper($fromJSON);

The result is $VAR1 = [ '1', '2', '3', '4' ];

Which is an array ref, where your result is a hash ref

So did you pass in a hash with element items which was a reference to an array?

In my example you would get the array by doing

my @array = @{ $fromJSON };

In yours

my @array = @{ $content->{'items'} }

I don't understand why you dislike the arrow operator so much!

The decode_json function from the JSON module will always return a data reference.

Suppose you have a Perl program like this

use strict;
use warnings;

use JSON;

my $json_data = '{ "items": [ 1, 2, 3, 4 ] }';

my $content = decode_json($json_data);

use Data::Dump;
dd $content;

which outputs this text

{ items => [1 .. 4] }

showing that $content is a hash reference. Then you can access the array reference, as you found, with

dd $content->{items};

which shows

[1 .. 4]

and you can print the first element of the array by writing

print $content->{items}[0], "\n";

which, again as you have found, shows just

1

which is the first element of the array.

As @cjm mentions in a comment, it is imperative that you use strict and use warnings at the start of every Perl program. If you had those in place in the program where you tried to access $content{items}, your program would have failed to compile, and you would have seen the message

Global symbol "%content" requires explicit package name

which is a (poorly-phrased) way of telling you that there is no %content so there can be no items element.

The scalar variable $content is completely independent from the hash variable %content, which you are trying to access when you write $content{items}. %content has never been mentioned before and it is empty, so there is no items element. If you had tried @{$content->{items}} then it would have worked, as would @{${$content}{items}}

If you really have a problem with the arrow operator, then you could write

print ${$content}{items}[0], "\n";

which produces the same output; but I don't understand what is wrong with the original version.