Arrays and hashes are both bunches of pigeon holes where you can store values. The difference is how you get at any particular pigeon hole.

For an array each pigeon hole has a number (the 'index') which ranges from 0 to one less than the number of pigeon holes.

For a hash each pigeon hole has a label and you access the pigeon hole by whatever is written on the label. I understand that PHP only has labeled pigeon holes (hashes), but of course if you label them with a sequence of numbers from 0 to n - 1 the effect is somewhat like using an array (but less efficient in various ways).

Perl arrays are fairly efficient for implementing things like stacks and queues using push, pop, shift and unshift. They are also easy to access from either end - $array[-1] is the last element of a (non-empty) array for example. They are good for storing things where the order is important. Arrays are a poor choice if you need to search for stuff in them often.

Perl hashes are good for storing things you want to get at by name and where order is unimportant. They are an excellent choice where you need to determine if you already have an entry of a particular name already which often makes them the tool of choice when you need to look stuff up frequently.

Thanks for helping me understand. Regards, Rahul srbworld

thanks, this was very useful!

A hash is a set of key/value pairs of unordered items, useful when you want to quickly get from a key to its corresponding value no matter how large the data set might get.

Or, in short: hashes are for mapping, arrays are for ordering.

Data: Arrays
Data: Hashes (Associative Arrays)
perldsc
perllol

why would it be a bad idea for them to be merged into the same data structure?

Sometimes it is a good idea to merge them. For these occasions there are modules that provide the mapping ability of hashes and the ordering ability of arrays in the same data object.

Often, hash lookup is needed but ordering is not required. In these cases, it would be a waste of resource to maintain un-needed ordering of the hash keys. For small data sets the difference wouldn't be very much but Perl can handle very large hashes. For these large hashes, the work of inserting a new element would be significantly greater if the new key had to be inserted into an ordered list.

Similarly, if all that is needed is an ordered list of items, the implementation of the numerically indexed array is more efficient than that of the hash lookup. One could use a hash with keys 0, 1, 2, etc. but it would be slower than an array for many operations.

So, the reason it would be bad to merge arrays and hashes is that doing so would make many common cases less efficient (slower and/or consuming more resource).

In perl that used to be called pseudohash, but they were removed.

Pseudohash goes the other way, though. Pseudohashes were arrays internally, with a hash glued on so that the items could be accessed by key. The "ordered hash" as provided by PHP or IxHash is a hash primarily, with an array glued on to provide an ordering.

Perl hashes are associative arrays. They're called hashes because they're implemented as hash tables.

If I understood correctly, you called $array = array(1, 2, 3, 4); an associative array. It's not. It's just an array (if that) because the values aren't associated with anything.

Actually, in perl it's pretty similar:

@array = ( 1, 2, 3, 4 );
%hash = ( red=>1, blue=>2, green=>3, yellow=>4 );

print join(" | ", reverse @array);
print join(" | ", keys %hash);
[download]

# somewhere, some step ends up doing something like:

$index = 256 * 2048 * 1024 * 1024 * $i;  # for some value of $i >= 1

# and then, shortly afterwards, something like this happens:

$array( $index ) = "foobar";
[download]

That sort of thing would not cause a problem in Perl either, if you are using a hash. But Perl gives you the opportunity of using an array instead ($array[$index]='foobar' rather than $hash{$index}='foobar'), and when you give a ridiculously large index value for an element in an array, Perl is obliged to make sure that memory is allocated to hold all the array slots between "0" and the given index value.

So, if you are being careless in your use of (numerically indexed) arrays in perl -- when you should really be using a hash instead -- what is actually happening, in effect, is that perl is giving you enough rope to hang yourself, whereas PHP is allowing you to ignore the fact that your numeric "array" index values may sometimes be insane (and obviously bug-ridden).

Not a perfect world, either way...