PHP arrays are essentially ordered hash tables, rather than traditional continuous memory arrays; 1. It realizes O(1) average search through hash function, and maintains the insertion order with two-way linked lists; 2. Each element is stored in a bucket, including keys, hash values, pointers to zval and linked list pointers; 3. The key type will be automatically converted: string numbers to integers, floating point truncation, boolean values to 0/1, and null to empty strings; 4. Each element consumes a lot of memory (zval is about 16–24 bytes, bucket is about 72 bytes), resulting in significant memory overhead in large arrays; 5. Foreach traversal is based on linked lists, and the order is stable, but array_reverse needs to be rebuilt O(n); 6. Hash conflicts may degenerate the lookup to O(n), and PHP 7.2 introduces randomized hash defense collision attacks; 7. Array assignment uses copy-on-write (COW), and references share the same hash table; 8. In actual development, you should avoid loading massive data into arrays, give priority to using generators, use array_key_exists and array_keys with caution, and recommend isset for existence checks - understanding these mechanisms will help optimize performance and memory usage, and ultimately implement efficient PHP programming.

When you work with PHP arrays every day, it's easy to take them for granted. They're flexible—used as lists, dictionaries, stacks, or even pseudo-objects. But what happens under the hood? To truly master PHP performance and memory usage, especially in high-load applications, you need to go beyond the basics and understand PHP's array internals.

Unlike arrays in lower-level languages like C, PHP arrays aren't simple continuous blocks of memory. Instead, they're implemented as ordered hash tables —a powerful hybrid structure that enables both fast key-value looksups and ordered traversal. Let's break down how this works.

How PHP Arrays Are Actually Hash Tables

At the core, a PHP array is an ordered hash table (also known as a hashtable with a linked list ). This dual nature allows:

• Fast key-based access (average O(1) lookup via hash)
• Maintained insertion order (via a double-linked list)

This is why you can do:

 $array['name'] = 'John';
$array[42] = 'answer';
$array['3.14'] = 'pi';

… and PHP handles strings, integers, and even numeric strings seamlessly.

Internally, PHP uses the Zend Engine's HashTable structure , which contains:

• A hash function to map keys to buckets
• Buckets that store key-value pairs (zvals)
• A double-linked list connecting entries in insertion order
• A size field and hash table mask for fast indexing

Each element in the array is stored in a bucket , and buckets are grouped into a hash table array based on the hash of the key. Collisions (when two keys hash to the same index) are resolved via chaining.

Key Internals: zvals, Buckets, and Type Juggling

1. zvals: The Universal Value Container

Every value in PHP—whether int, string, or object—is stored in a zval (Zend value). In PHP 7 , zval is a compact struct that includes:

• The actual value (or pointer)
• A type tag (eg, IS_LONG, IS_STRING)
• Reference count (for GC)
• Garbage collection info

When you assign a value to an array:

 $arr['key'] = 42;

PHP creates a zval with type IS_LONG and value 42 , then stores it in the hash table.

2. Buckets: Where Key-Value Pairs Live

Each bucket in the hash table contains:

• The hash of the key
• The key itself (either string or numeric)
• Pointer to the zval
• Next/prev points for collision chains
• h (the numeric hash key used for integer-like keys)

For string keys, the full string is stored. For numeric keys (including stringified numbers), PHP normalizes them to integers internally when possible.

3. Type Coercion in Keys

PHP silently normalizes array keys:

 $arr[1] = 'one';
$arr['1'] = 'string one'; // overwrites previous!
$arr[1.9] = 'float'; // becomes key 1, overwrites again

This happens because:

• String keys that look numeric → converted to integers
• Floats → truncated to integers (not rounded!)
• true → 1, false → 0, null → '' (empty string)

So the hash table only allows long or string keys—everything else gets coerced.

Memory Overhead: Why Big Arrays Are Expensive

A PHP array isn't just data—it's metadata-heavy. For each element, you're storing:

So a simple array like:

 $array = [1, 2, 3];

… might use hundreds of bytes , not just 3 integers.

This is why loading 100,000 rows into a PHP array can consume tens of megabytes —each row adds multiple zvals, buckets, and possibly duplicated strings.

? Tip: Use generators or iterative processing instead of loading everything into arrays when possible.

Performance Implications

Iteration Order Is Predictable (But Not Free)

Because PHP arrays maintain insertion order via a linked list, foreach is fast and consistent:

 foreach ($array as $key => $value) { ... }

Internally, PHP follows the linked list of buckets , not the hash table—so order is preserved without sorting.

But this also means:

• array_reverse() has to rebuild the entire hash table (O(n))
• ksort() reorders the linked list based on keys, but doesn't rehash

Hash Collisions Can Slow Things Down

In worst-case scenarios (eg, many colliding keys), lookup degrades to O(n) instead of O(1). While rare in practice, this can be exploited in hash collision attacks (a security concern in older PHP versions).

PHP now uses randomized hash functions (since 7.2) to prevent predictable collisions.

Advanced Behavior: References and Copy-on-Write

PHP arrays use copy-on-write (COW) semantics:

 $a = [1, 2, 3];
$b = $a; // No copy yet
$b[] = 4; // Now $b gets a real copy

Under the hood:

• Both $a and $b point to the same HashTable
• The refcount is incremented
• Only when one is modified does PHP makes a full copy

But with references:

 $b = &$a; // Now they share even on write

The engine tracks this and avoids copying—changes to one affect the other.

This makes array assignment efficient but can cause subtle bugs if you're not aware of when copies happen.

Practical Takeaways

Understanding PHP's array internals helps you write better, more efficient code:

• ? Avoid huge arrays in memory – use generators, iterators, or process in chunks
• ? Be careful with array keys – numeric strings become integers, which can cause overwrites
• ? Prefer isset() over array_key_exists() when possible – isset() uses the hash table directly (faster)
• ? Use array_keys($arr, $search) cautiously – it's O(n), not optimized by the hash
• ? Don't assume low memory usage – arrays are powerful but expensive

Basically, PHP arrays are not arrays in the traditional sense. They're sophisticated, flexible, and convenient—but come with trade-offs in memory and performance. Knowing how they work lets you use them wisely, especially when scaling.

It's not magic—it's a hash table with a linked list, and a lot of clever engineering. But now you know what's really going on when you write $arr['hello'] = 'world'; .

The above is the detailed content of Beyond the Basics: A Deep Dive into PHP's Array Internals. For more information, please follow other related articles on the PHP Chinese website!