The five faces of a Perl hash item

PHP calls it associative array, JavaScript calls it object and - in the eyes of other (older) languages like C, BASIC, Pascal or Perl - all of them are wrong. An array has some items which may be addressed using their position in the list, but only a Perl hash has named keys. A hash is basically an (unordered) list of items where each item has a key and a value - but that value may have one of many different states.

I love to think of Perl as a pure logical language with very few exceptions, but I'll switch to a developers point of view and include some "states" which aren't clearly hash-related but very common.

Hash basics

A hash is basically a list of items:

Each unique key has exactly one value which isn't unique. The size of a hash is only limited by the amout of memory available to the Perl process and so are key and value. One way of defining a hash with values is

my %sample = (
   1   => 'One',
   foo => 'bar',
   baz => 'bar',
);

The key doesn't need quotes as long as it contains only \w+ (which includes A to Z, a to z, 0 to 9 and the underscore _ ) and is no reserved Perl keyword. That's not exactly official, but my personal definition. Anything else goes between quotes and in any doubt: Use quotes. Same for key names between { and }.

print $sample{1};
print $sample{foo};

1. Exists

From a pure Perl core point of view, exists is the only real state of a hash item. Using the sample hash (table) above, the keys 1, foo and baz exist, but keys like bar or The flying spaghetti monster don't exist. The exists function is the only chance of checking this:

exists($sample{foo});                            # returns 1 (=true)
exists($sample{'The flying spaghetti monster'}); # returns undef (=false)

2. Defined

One may think of the exists function as some kind of check if one exact key has been created within the hash. The defined function is often being used as exists replacement, but that's not true. Any existing key may have a defined or undefined value.

$sample{exists_but_not_defined} = undef;
exists($sample{exists_but_not_defined});  # returns true
defined($sample{exists_but_not_defined}); # returns false

It's perfectly ok to use an undef value within a hash. Hashes are often used to collect a list of unique values and I like to use 1 as a default value, but there is no need to assign any value. The keys function will report all keys, even if (some of) their values are undef.

3. False

The next common mistake: A hash item's value may by defined, but still false (like any scalar variable's contents):

$sample{false_value} = 0;
exists($sample{false_value});  # returns true
defined($sample{false_value}); # returns true
$sample{false_value};          # returns false

The hash key false_value exists and has a defined value - but the value is still false. Trying to use the last check for testing the existance if an item will fail.

4. True

Testing for a true value is nearly the same as testing for a false value:

$sample{true_value} = 1;
exists($sample{true_value});  # returns true
defined($sample{true_value}); # returns true
$sample{true_value};          # returns true

All tests return true now. You shouldn't mix them up, but it's ok to simply test for a true value if you need only hash elements with true values:

for my $key (@expected_keys) {
   next unless $sample{$key};
   $sum += $sample{$key}; # Or do anything really useful here
}

The first line within the loop skips all items from the list of @expected_keys which match one of the following conditions:

• The expected key doesn't exist within the hash %sample.
• The key exists, but has an undefined value.
• The value is defined, but empty or zero.

Any positive or negative number and any text value will be added, all others will be skipped without issuing a warning even if use warnings; has been used before.

5. Hashref

Pretty much the same as true above, but a special case from a developers point of view: Any hash item value may hold any reference. A reference to a hash is very common, but array-references, objects and any other type of reference is allowed as hash value (but not as key!).