Answer.

In Perl, there are several ways to traverse hashes: through each, through the list of keys (keys) and foreach, as well as through values. From the very beginning of the language, it was intended that hashes would be used for quick data access, so the traversal methods were created with performance and minimizing additional memory allocation in mind.

Problem: Using these techniques can lead to many pitfalls: modifying the hash during traversal, remembering the iterator, the order of elements, side effects of each on the hash, and the risk of unexpected behavior during nested iteration.

Solution: For safe and predictable iteration, it is recommended to use foreach my $key (sort keys %hash), not to modify the hash during traversal, and for each — always reset the iterator using keys %hash before a new cycle.

Example code:

my %hash = (
   a => 1, b => 2, c => 3
);
foreach my $key (sort keys %hash) {
    print "$key: $hash{$key}
"; # Predictable order
}

Key characteristics:

Iteration through keys returns a copy of the list of keys, the order is not defined.
The each iterator is remembered on the hash, multiple cycles simultaneously are only possible with different hashes.
To reset the each iterator, an empty call to keys is used.

Tricky Questions.

Can you safely modify a hash while iterating through each?

No, this leads to uncontrollable consequences: data may be missed or counted multiple times.

If you call each for two different hashes, will there be a shared iterator?

No, iterators are independent for each hash.

Can you nest two each loops for the same hash?

No, the iterator will "break" and the results will be unpredictable. For such cases, use keys and nested loops.

Common Mistakes and Anti-Patterns

Modifying a hash during iteration through each
Leaving an uninitialized each iterator
Attempting simultaneous nested iteration over one hash using each

Real-Life Example

Negative Case

Using each to traverse a hash in a function that is called repeatedly with different parts of the same hash. The iterator breaks, and some data is lost.

Pros:

each works faster with a large hash if partial element processing is required.

Cons:

Unpredictable behavior, "loss" of data.

Positive Case

Using foreach and keys for traversal, full iteration with explicit saving of keys in a separate array.