%hash = (this => "one", that => two);
print Dumper (\%hash);
[download]

Also note that it should be

%hash = (this => "one", that => two);
[download]

Instead of

%hash = {this => "one", that => two};
[download]

You use {} to initialize a hash reference, and () to initialize an actual hash.

Add use strict; use warnings; at the start of every script you write. They will save you time! In this case the two errors in your hash assignment would have been flaged. One at compile time (two as a bareword) and the other at run time (the reference as 'Reference found where even-sized list expected').

and in the interests of TIMTOWTDI:

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

my %hash = (this => 'one', that => 'two');

print "Dumpered:\n" . Dumper (\%hash);

print "\nStreamered:\n";
Dump (\%hash);

print "\nikegamied:\n";
foreach my $key (keys %hash) {
   my $val = $hash{$key};
   print("$key => $val\n");
}

print "\nGrandFathered:\n";
print "$_ => $hash{$_}\n" for keys %hash;

print "\nmapped:\n";
print map {"$_ => $hash{$_}\n"} keys %hash;
[download]

Prints:

Dumpered:
$VAR1 = {
          'that' => 'two',
          'this' => 'one'
        };

Streamered:
$HASH1 = {
           that => 'two',
           this => 'one'
         };

ikegamied:
that => two
this => one

GrandFathered:
that => two
this => one

mapped:
that => two
this => one
[download]

No, you're not an idiot. You're going through the same thing(s) I have, and still do sometimes. :-)

IMHO, one of the best discussions of complex data structures, and how to access their innards (and by extension, get all the regular parenthesis, curly things, etc., straight in your head), is to be found in Chapter 3. References and complex data structures of perlinter.pdf, available from Perl Training Australia. You'd probably want the most current version of the course notes, though, which have been reworked into progperl.pdf, available from the same page noted above.

You may also wish to take a look at the following:

• intro to references
• References quick reference
• Not Exactly a Hash Tutorial
• The Uniqueness of hashes.
• Re: How can I visualize my complex data structure?

HTH,

# Parens, not curlies
my %hash = (this => "one", that => "two"); 
# Use a slash when dumping @var or %var
print Dumper(\%hash);
print($hash{this}, "\n");
[download]

Curlies create an anonymous hash and return a reference to that hash. Hashes are initialized from a list, not from a hash reference. Use parens (not curlies) to create a list.

If you wanted to work with a hash reference, use curlies, and assign the result of the curlies to a scalar.

my $hash = { this => "one", that => "two" }; 
print Dumper($hash);
print($hash->{this}, "\n");
[download]

For example, using your sample above:

use Data::Dumper;
my %hash = (
        this => "one",
        that => "two",
    );
print Dumper(\%hash);
[download]

$VAR1 = {
          'that' => 'two',
          'this' => 'one'
        };
[download]

use Data::Dumper::Simple;
my %hash = (
        this => "one",
        that => "two",
    );
print Dumper(%hash);
[download]

%hash = (
          'that' => 'two',
          'this' => 'one'
        );
[download]

Notice two things:

• There is no need to pass a reference to the hash to Dumper.
• The output includes the variable (hash) name, which makes it easier to read.

One thing you should be aware of is that Data::Dumper::Simple uses source filtering techniques (which is probably why many people refuse to use it). Personally, this doesn't bother me as I only ever use it for debugging.

Cheers,
Darren :)

%hash = (this => 'one', that => 'two');
print join(', ', map({ "$_ => $hash{$_}" } sort keys %hash)), "\n";
[download]