When is it better to use an array instead of a hash in Perl?

Question

Say you have an array @a = qw/ a b c d/;

and a hash %a = ('a' => 1, 'b' => 1, 'c' => 1, 'd' => 1);

Is there any situation where creating the array version is better than creating the hash (other than when you have to iterate over all the values as in something like

for (@a){
    ....

in which case you would have to use keys %a if you went with the hash)? Because testing whether a specific value is in a hash is always more efficient than doing so in an array, correct?

Answer 1

1. • Arrays are indexed by numbers.
   • Hashes are keyed by strings.

2. • All indexes up to the highest index exist in an array.
   • Hashes are sparsely indexed. (e.g. "a" and "c" can exist without "b".)

There are many emergent properties. Primarily,

1. • Arrays can be used to store ordered lists.
   • It would be ugly an inefficient to use hashes that way.

2. • It's not possible to delete an element from an array unless it's the highest indexed element.
   • You can delete from an ordered list implemented using an array, though it is inefficient to remove elements other than the first or last.
   • It's possible to delete an element from a hash, and it's efficient.

Answer 2

Arrays are ordered lists of values. They can contain duplicate values.

@array = qw(a b c a);

Hashes are a mapping between a key (which must be unique) and a value (which can be duplicated). Hashes are (effectively) unordered, which means that keys come out in apparently random order rather than the order in which they are entered.

%hash = (a => 1, b => 2, c => 3);

Hashes can also be used as sets when only the key matters. Sets are unordered and contain only unique "values" (the hash's keys).

%set = (a => undef, b => undef, c => undef);

Which one to use depends on your data and algorithm. Use an array when order matters (particularly if you can't sort to derive the order) or if duplicate values are possible. Use a set (i.e. use a hash as a set) when values must be unique and don't care about order. Use a hash when uniqueness matters, order doesn't (or is easily sortable), and look-ups are based on arbitrary values rather than integers.

You can combine arrays and hashes (via references) to create arbitrarily complex data structures.

@aoa = ([1, 2, 3], [4, 5, 6]);               # array of arrays ("2D" array)
%hoh = (a => { x => 1 }, b => { x => 2 });   # hash of hashes
@aoh = ({a => 1, b => 2}, {a => 3, b => 4}); # array of hashes
%hoa = (a => [1, 2], b => [3, 4]);           # hash of arrays
...etc.