Basically, Data::Dumper takes a perl datastructure and turns it into a string containing perl code that, when eval()ed (that is, run as code), returns an equivalent data structure. This is useful for many reasons, but a very simple use is to print out a data-structure to see if it matches what you think it is.

Example:

use Data::Dumper qw(Dumper); # impor the Dumper() subroutine
my %hash = ( a => 1, b => 2, c => 3 );
print Dumper(\%hash);  # note the \ backslash; Dumper() takes referenc
+es as arguments
[download]

$VAR1 = {
          'c' => 3,
          'a' => 1,
          'b' => 2
        };
[download]

Data::Dumper (and the similar Data::Dump::Streamer) are used to look at the contents of variables - generally for diagnostic purposes. They can also be used to serialise a data structure so that it can be persisted to disk (saved and restored later). Data::Dump::Streamer does a better job of handling edge cases than Data::Dumper. Consider:

use strict;
use warnings;
use Data::Dumper;
use Data::Dump::Streamer;

my %hash = (
     this => ['one', 2, 3.1],
     that => undef,
     );

print Dumper (\%hash);
Dump (\%hash);
[download]

Prints:

$VAR1 = {
          'that' => undef,
          'this' => [
                      'one',
                      2,
                      '3.1'
                    ]
        };
$HASH1 = {
           that => undef,
           this => [
                     'one',
                     2,
                     3.1
                   ]
         };
[download]

I don't know, the first sentence in the Data::Dumper page seems pretty clear to me:

Data::Dumper - stringified perl data structures, suitable for both printing and eval

Stringified may not be a real word, but it means "turned into a string" (which according to the Oxford Dictionary, is "a linear sequence of characters, words, or other data").

Perl Data Structure is pretty straightforward - it's a structured hunk of data in perl.

Suitable for printing means you can print it.

Suitable for eval means you can copy and paste it as valid perl code.

Try a few things:

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my %hash = ( 'test' => 'one', 'next' => 'two' );

print Dumper \%hash;

__OUTPUT__
$VAR1 = {
          'next' => 'two',
          'test' => 'one'
        };
[download]

s**lil*;  $*=join'',sort split q**;  s;.*;grr; &&s+(.(.)).+$2$1+; $; =
qq-$_-;s,.*,ahc,;$,.=chop for split q,,,reverse;print for($,,$;,$*,$/)
[download]

In Perl, a hash can hold a hierarchy of data and can be a mix of different data types. It can a simple key => value list or a or could be something really complicated.

Because a hash can get complicated, you need a way of getting a picture of the data structure. Data::Dumper allows you to dump out this data structure. Now you can see the what and the how of the structure.

Example: I was trying to get data from $hash_ref->{shoppingcart} and the data was in $hash_ref->{shopping_cart}.

Note: All the '', {} and [] characters you see do mean something. If you are a beginner it can be hard to understand what is all those symbols mean. Trust me, they are very important and you will need to learn them.

You can use Data::Dumper to print out a stringified representation of data whenever you want, error condition or not. Here is an answer to another SoPW with an example of Data::Dumper being used to visualise the data that the program has constructed. Note that the output produced is valid Perl code which could be printed to a file, read back in by another script and evaled to re-create the data.

I hope this clarifies things.

Cheers,

JohnGG

I hope Not Exactly a Hash Tutorial was useful to you. You might also find value in How can I visualize my complex data structure?.