That looks very much like JSON, so you'd need to use a JSON module like Cpanel::JSON::XS, or JSON::PP has been in the core since Perl 5.14.

If you need help in further processing this data and looping over it, then please explain what you'd like to do (with code) and what your expected output is. See also perldsc, perlreftut, and perlref.

G'day SergioQ,

Your "raw data" is JSON. Take a look at JSON. If you also have JSON::XS installed it will run faster.

What you want to do should be fairly straightforward from the example code in the SYNOPSIS.

The data you have is JSON. And a module such as JSON has decode_json to convert it to a Perl data structure. Alternatively, if you don't want to install JSON, Perl ships with JSON::PP, which is a drop-in replacement (or fall-back).

#!/usr/bin/env perl

use strict;
use warnings;
use JSON qw(decode_json);

my $json = do {
    local $/ = undef;
    <DATA>;
};

my $data = decode_json($json);

foreach my $element (@{$data->{'genres'}}) {
    print "id: $element->{'id'}, name: $element->{'name'}\n";
}

__DATA__
{
  "genres": [
    {
      "id": 28,
      "name": "Action"
    },
    {
      "id": 12,
      "name": "Adventure"
    },
    {
      "id": 16,
      "name": "Animation"
    },
    {
      "id": 35,
      "name": "Comedy"
    },
    {
      "id": 80,
      "name": "Crime"
    },
    {
      "id": 99,
      "name": "Documentary"
    },
    {
      "id": 18,
      "name": "Drama"
    },
    {
      "id": 10751,
      "name": "Family"
    },
    {
      "id": 14,
      "name": "Fantasy"
    },
    {
      "id": 36,
      "name": "History"
    },
    {
      "id": 27,
      "name": "Horror"
    },
    {
      "id": 10402,
      "name": "Music"
    },
    {
      "id": 9648,
      "name": "Mystery"
    },
    {
      "id": 10749,
      "name": "Romance"
    },
    {
      "id": 878,
      "name": "Science Fiction"
    },
    {
      "id": 10770,
      "name": "TV Movie"
    },
    {
      "id": 53,
      "name": "Thriller"
    },
    {
      "id": 10752,
      "name": "War"
    },
    {
      "id": 37,
      "name": "Western"
    }
  ]
}
[download]

This produces:

id: 28, name: Action
id: 12, name: Adventure
id: 16, name: Animation
id: 35, name: Comedy
id: 80, name: Crime
id: 99, name: Documentary
id: 18, name: Drama
id: 10751, name: Family
id: 14, name: Fantasy
id: 36, name: History
id: 27, name: Horror
id: 10402, name: Music
id: 9648, name: Mystery
id: 10749, name: Romance
id: 878, name: Science Fiction
id: 10770, name: TV Movie
id: 53, name: Thriller
id: 10752, name: War
id: 37, name: Western
[download]

A foreach loop is useful here, as described in perlintro or perlsyn. Dealing with complex data structures is covered in Intermediate Perl (OReilly), in perlreftut, perlref, perldsc, and perllol.

use JSON;
use Data::Dumper;
use strict;
use warnings;

my $json = JSON->new->allow_nonref;


my $raw = do { undef $/; <DATA> };
my $ds = $json->decode( $raw );

if(0)
{
# this replaces the value of 'genres' with a hash more like what you w
+ant:
for my $key ( keys %$ds ) # e.g. 'genres'
{
    my %h;
    for my $r ( @{ $ds->{$key} } )
    {
        $h{$r->{'id'}} = $r->{'name'};
    }
    $ds->{$key} = \%h; # replace it!
}
print Dumper $ds;
}

# or if you really want to 'invert' the hash, so that 'id's are at the
+ top:
my %data;
for my $key ( keys %$ds ) # e.g. 'genres'
{
    my %h;
    for my $r ( @{ $ds->{$key} } )
    {
        $data{$r->{'id'}}{$key} = $r->{'name'};
    }
}
print Dumper \%data;


__DATA__
{
  "genres": [
    {
      "id": 28,
      "name": "Action"
    },
    {
      "id": 12,
      "name": "Adventure"
    },
    {
      "id": 16,
      "name": "Animation"
    },
    {
      "id": 35,
      "name": "Comedy"
    },
    {
      "id": 80,
      "name": "Crime"
    },
    {
      "id": 99,
      "name": "Documentary"
    },
    {
      "id": 18,
      "name": "Drama"
    },
    {
      "id": 10751,
      "name": "Family"
    },
    {
      "id": 14,
      "name": "Fantasy"
    },
    {
      "id": 36,
      "name": "History"
    },
    {
      "id": 27,
      "name": "Horror"
    },
    {
      "id": 10402,
      "name": "Music"
    },
    {
      "id": 9648,
      "name": "Mystery"
    },
    {
      "id": 10749,
      "name": "Romance"
    },
    {
      "id": 878,
      "name": "Science Fiction"
    },
    {
      "id": 10770,
      "name": "TV Movie"
    },
    {
      "id": 53,
      "name": "Thriller"
    },
    {
      "id": 10752,
      "name": "War"
    },
    {
      "id": 37,
      "name": "Western"
    }
  ]
}
[download]

use strict;
use warnings;

(my $datastring=do{local $/=undef; <DATA>}) =~s/:/=>/g;
my $data = eval $datastring;

my %by_name = map { $_->{name} => $_->{id} } @{$data->{'genres'}};
print "The ID for Science Fiction is:", $by_name{"Science Fiction"} , 
+"\n";
__DATA__
<<<YOUR JSON Here...>
[download]

The ID for Science Fiction is:878
[download]

NOT RECOMMENDED

I feel like this should be at the top of the node.

But if you're going down that route, then this classic node is worth pointing out: JSON parser as a single Perl Regex, which works on the data in the root node when you apply fanasy's fix from here. Update: To be clear, I'm not seriously suggesting this as a solution here :-)

If JSON::PP is in core, why avoid it and suggest code with a caveat that it shouldn't be used due to badness?

Update Correct JSON to JSON::PP - thanks Haarg

Optimising for fewest key strokes only makes sense transmitting to Pluto or beyond

JSON is not in core. JSON::PP is.

Some potential excuses:
• Older perl, missing core JSON
• Too scared/lazy/ignorant to use JSON
• Because you can

                "Imaginary friends are a sign of a mental disorder if they cause distress, including antisocial behavior. Religion frequently meets that description"

If you replace : with => (or even a comma), then you'd have PON - Perl Object Notation, also known as actual Perl code. So having that you could then do something silly like prepend our $hash_ref = then string eval or write it to a file then require it:

And if - for some nasty reason - the input suddenly contains something like "foo" : `rm -rf /` ("foo" => `rm -rf /` after replacing : with =>), you will learn the hard way why you don't blindly run configuration data as executable code. JSON, JSON::PP, and JSON::XS all treat data as such and do not treat the input as executable code. Hell, you don't even eval() JSON in Javascript - for the same reason.

See also:

• Re^2: conf file in Perl syntax
• Re: Accessing variables in an external hash without eval
• Re^4: The safety of string eval and block eval.
• Re^2: Storing state of execution
• Re: What's the right way to include a config file as a .pm bareword?
• Re^4: how to read conf file in perl script

Alexander

--
Today I will gladly share my knowledge and experience, for there are no sweeter words than "I told you so". ;-)

To be fair, accepting rando Storable input files has thia caveat. My only point that it was very close to defining a hash ref.