When you first hear about hashes, especially if you’ve lived a long and productive life as a programmer using other languages that don’t have hashes, you may wonder why anyone would want one of these strange beasts. Well, the general idea is that you’ll have one set of data “related to” another set of data. For example, here are some hashes you might find in typical applications of Perl:

So, yet another way to think of a hash is as a very simple database, in which just one piece of data may be filed under each key. In fact, if your task description includes phrases like “finding duplicates,” “unique,” “cross-reference,” or “lookup table,” it’s likely that a hash will be useful in the implementation.

To refer to the entire hash, use the percent sign (”%“) as a prefix. So, the hash we’ve been using for the last few pages is actually called %family_name.

For convenience, a hash may be converted into a list, and back again. Assigning to a hash (in this case, the one from Figure 5-1) is a list-context assignment, where the list is made of key-value pairs:^[7]

%some_hash = ("foo", 35, "bar", 12.4, 2.5, "hello",
      "wilma", 1.72e30, "betty", "bye
");

The value of the hash (in a list context) is a simple list of key-value pairs:

@any_array = %some_hash;

We call this unwinding the hash; turning it back into a list of key-value pairs. Of course, the pairs won’t necessarily be in the same order as the original list:

print "@any_array
";
  # might give something like this:
  #  betty bye (and a newline) wilma 1.72e+30 foo 35 2.5 hello bar 12.4

The order is jumbled because Perl keeps the key-value pairs in an order that’s convenient for Perl, so that it can look up any item quickly. So you’d normally use a hash either when you don’t care what order the items are in, or when you have an easy way to put them into the order you want.

Of course, even though the order of the key-value pairs is jumbled, each key “sticks” with its corresponding value in the resulting list. So, even though we don’t know where the key foo will appear in the list, we know that its value, 35, will be right after it.

It’s rare to do so, but a hash may be copied using the obvious syntax:

%new_hash = %old_hash;

This is actually more work for Perl than meets the eye. Unlike what happens in languages like Pascal or C, where such an operation would be a simple matter of copying a block of memory, Perl’s data structures are more complex. So, that line of code tells Perl to unwind the %old_hash into a list of key-value pairs, then assign those to %new_hash, building it up one key-value pair at a time.

It’s more common to transform the hash in some way, though. For example, we could make an inverse hash:

%inverse_hash = reverse %any_hash;

This takes %any_hash and unwinds it into a list of key-value pairs, making a list like ( key, value, key, value, key, value, ...). Then reverse turns that list end-for-end, making a list like ( value, key, value, key, value, key, ...). Now the keys are where the values used to be, and the values are where the keys used to be. When that’s stored into %inverse_hash, we’ll be able to look up a string that was a value in %any_hash—it’s now a key of %inverse_hash. And the value we’ll find is one that was one of the keys from %any_hash. So, we have a way to look up a “value” (now a key), and find a “key” (now a value).

Of course, you might guess (or determine from scientific principles, if you’re clever) that this will work properly only if the values in the original hash were unique—otherwise we’d have duplicate keys in the new hash, and keys are always unique. Here’s the rule that Perl uses: the last one in wins. That is, the later items in the list overwrite any earlier ones. Of course, we don’t know what order the key-value pairs will have in this list, so there’s no telling which ones would win. You’d use this technique only if you know there are no duplicates among the original values.^[8] But that’s the case for the IP address and host name examples given earlier:

%ip_address = reverse %host_name;

Now we can look up a host name or IP address with equal ease, to find the corresponding IP address or host name.

When assigning a list to a hash, sometimes it’s not obvious which elements are keys and which are values. For example, in this assignment (which we saw earlier), we humans have to count through the list, saying, “key, value, key, value...”, in order to determine whether 2.5 is a key or a value:

%some_hash = ("foo", 35, "bar", 12.4, 2.5, "hello",
      "wilma", 1.72e30, "betty", "bye
");

Wouldn’t it be nice if Perl gave us a way to pair up keys and values in that kind of a list, so that it would be easy to see which ones were which? Larry thought so, too, which is why he invented the big arrow, (=>).^[9] To Perl, it’s just a different way to “spell” a comma. That is, in the Perl grammar, any time that you need a comma ( , ), you can use the big arrow instead; it’s all the same to Perl.^[10] So here’s another way to set up the hash of last names:

my %last_name = (  # a hash may be a lexical variable
  "fred" => "flintstone",
  "dino" => undef,
  "barney" => "rubble",
  "betty" => "rubble",
);

Here, it’s easy (or perhaps at least easier) to see whose name pairs with which value, even if we end up putting many pairs on one line. And notice that there’s an extra comma at the end of the list. As we saw earlier, this is harmless, but convenient; if we need to add additional people to this hash, we’ll simply make sure that each line has a key-value pair and a trailing comma. Perl will see that there is a comma between each item and the next, and one extra (harmless) comma at the end of the list.

The keys function yields a list of all the current keys in a hash, while the values function gives the corresponding values. If there are no elements to the hash, then either function returns an empty list:

my %hash = ("a" => 1, "b" => 2, "c" => 3);
my @k = keys %hash;
my @v = values %hash;

So, @k will contain "a", "b", and "c", and @v will contain 1, 2, and 3—in some order. Remember, Perl doesn’t maintain the order of elements in a hash. But, whatever order the keys are in, the values will be in the corresponding order: If "b" is last in the keys, 2 will be last in the values; if "c" is the first key, 3 will be the first value. That’s true as long as you don’t modify the hash between the request for the keys and the one for the values. If you add elements to the hash, Perl reserves the right to rearrange it as needed, to keep the access quick.^[11]

In a scalar context, these functions give the number of elements (key-value pairs) in the hash. They do this quite efficiently, without having to visit each element of the hash:

my $count = keys %hash;  # gets 3, meaning three key-value pairs

Once in a long while, you’ll see that someone has used a hash as a Boolean (true/false) expression, something like this:

if (%hash) {
  print "That was a true value!
";
}

That will be true if (and only if) the hash has at least one key-value pair.^[12] So, it’s just saying, “if the hash is not empty...”. But this is a pretty rare construct, as such things go.

If you wish to iterate over (that is, examine every element of) an entire hash, one of the usual ways is to use the each function, which returns a key-value pair as a two-element list.^[13] On each evaluation of this function for the same array, the next successive key-value pair is returned, until all the elements have been accessed. When there are no more pairs, each returns an empty list.

In practice, the only way to use each is in a while loop, something like this:

while ( ($key, $value) = each %hash ) {
  print "$key => $value
";
}

There’s a lot going on here. First, each %hash returns a key-value pair from the hash, as a two-element list; let’s say that the key is "c" and the value is 3, so the list is ("c", 3). That list is assigned to the list ($key, $value), so $key becomes "c", and $value becomes 3.

But that list assignment is happening in the conditional expression of the while loop, which is a scalar context. (Specifically, it’s a Boolean context, looking for a true/false value; and a Boolean context is a particular kind of scalar context.) The value of a list assignment in a scalar context is the number of elements in the source list—2, in this case. Since 2 is a true value, we enter the body of the loop and print the message c => 3.

The next time through the loop, each %hash gives a new key-value pair; let’s say it’s ("a", 1) this time. (It knows to return a different pair than previously because it keeps track of where it is; in technical jargon, there’s an iterator stored in with each hash.^[14]) Those two items are stored into ($key, $value). Since the number of elements in the source list was again 2, a true value, the while condition is true, and the loop body runs again, telling us a => 1.

We go one more time through the loop, and by now we know what to expect, so it’s no surprise to see b => 2 appear in the output.

But we knew it couldn’t go on forever. Now, when Perl evaluates each %hash, there are no more key-value pairs available. So, each has to return an empty list.^[15] The empty list is assigned to ($key, $value), so $key gets undef, and $value also gets undef.

But that hardly matters, because the whole thing is being evaluated in the conditional expression of the while loop. The value of a list assignment in a scalar context is the number of elements in the source list—in this case, that’s 0. Since 0 is a false value, the while loop is done, and execution continues with the rest of the program.

Of course, each returns the key-value pairs in a jumbled order. (It’s the same order as keys and values would give, incidentally; the “natural” order of the hash.) If you need to go through the hash in order, simply sort the keys, perhaps something like this:

foreach $key (sort keys %hash) {
  $value = $hash{$key};
  print "$key => $value
";
  # Or, we could have avoided the extra $value variable:
  #  print "$key => $hash{$key}
";
}

We’ll see more about sorting hashes in Chapter 15.

To see whether a key exists in the hash, (that is, whether someone has a library card or not), use the exists function, which returns a true value if the given key exists in the hash, whether the corresponding value is true or not:

if (exists $books{"dino"}) {
  print "Hey, there's a library card for dino!
";
}

That is to say, exists $books{"dino"} will return a true value if (and only if) dino is found in the list of keys from keys %books.

The delete function removes the given key (and its corresponding value) from the hash. (If there’s no such key, its work is done; there’s no warning or error in that case.)

my $person = "betty";
delete $books{$person};  # Revoke the library card for $person

Note that this is not the same as storing undef into that hash element—in fact, it’s precisely the opposite! Checking exists($books{"betty"}) will give opposite results in these two cases; after a delete, the key can’t exist in the hash, but after storing undef, the key must exist.

You can interpolate a single hash element into a double-quoted string just as you’d expect:

foreach $person (sort keys %books) {            # for each library patron,in order
  if ($books{$person}) {
    print "$person has $books{$person} items
";# fred has 3 items
  }
}

But there’s no support for entire hash interpolation; "%books" is just the six chararcters of (literally) %books.^[16] So we’ve seen all of the magical characters that need backslashing in double quotes: $ and @, because they introduce a variable to be interpolated; ", since that’s the quoting character that would otherwise end the double-quoted string; and , the backslash itself. Any other characters in a double-quoted string are non-magical and should simply stand for themselves.^[17]