The rule of thumb is to use the function most suited to your needs.

If you just want the keys and do not plan to ever *read* any of the values, use keys():

```
foreach my $key (keys %hash) { ... }
```

If you just want the values, use values():

```
foreach my $val (values %hash) { ... }
```

If you need the keys *and* the values, use each():

```
keys %hash; # reset the internal iterator so a prior each() doesn't affect the loop
while(my($k, $v) = each %hash) { ... }
```

If you plan to change the keys of the hash in any way *except* for deleting the current key during the iteration, then you must not use each(). For example, this code to create a new set of uppercase keys with doubled values works fine using keys():

```
%h = (a => 1, b => 2);
foreach my $k (keys %h)
{
$h{uc $k} = $h{$k} * 2;
}
```

producing the expected resulting hash:

```
(a => 1, A => 2, b => 2, B => 4)
```

But using each() to do the same thing:

```
%h = (a => 1, b => 2);
keys %h;
while(my($k, $v) = each %h)
{
$h{uc $k} = $h{$k} * 2; # BAD IDEA!
}
```

produces incorrect results in hard-to-predict ways. For example:

```
(a => 1, A => 2, b => 2, B => 8)
```

This, however, is safe:

```
keys %h;
while(my($k, $v) = each %h)
{
if(...)
{
delete $h{$k}; # This is safe
}
}
```

All of this is described in the perl documentation:

```
% perldoc -f keys
% perldoc -f each
```

According to Joshua Bloch's Effective Java (a book that can't be recommended enough, and which I bought thanks to continual mentions on stackoverflow):

The value 31 was chosen because it is an odd prime. If it were even and the multiplication overflowed, information would be lost, as multiplication by 2 is equivalent to shifting. The advantage of using a prime is less clear, but it is traditional. A nice property of 31 is that the multiplication can be replaced by a shift and a subtraction for better performance: `31 * i == (i << 5) - i`

. Modern VMs do this sort of optimization automatically.

*(from Chapter 3, Item 9: Always override hashcode when you override equals, page 48)*

## Best Solution

or just

if you're already in a scalar context, e.g.

`my $hash_count = keys %hash`

or`print 'bighash' if keys %hash > 1000`

.Incidentally,

`$#array`

doesn't find the number of elements, it finds the last index.`scalar @array`

finds the number of elements.