When you use $array[] = $value in PHP, the Zend Engine appends the value using the next integer key, determined by the cached nNextFreeElement in the HashTable structure, starting from 0 for empty arrays. 2. The operation begins with opcode execution (e.g., ASSIGN_DIM), followed by a check for writeability, triggering copy-on-write if the array’s refcount > 1, which may cause an O(n) duplication. 3. The engine inserts the value into a Bucket within the HashTable using a precomputed key, without scanning due to the cached next free index. 4. If the HashTable is full, PHP resizes it to the smallest power of 2 greater than 1.5 × current size, rehashes all elements, and frees the old table, resulting in O(n) cost but amortized O(1) over time. 5. Performance is optimized through packed array storage for consecutive integer keys, improving cache efficiency, and modern PHP versions enhance speed via better hashing, reduced overhead, and JIT compilation in loops. 6. Pitfalls include unexpected key assignment after high-index manual inserts, performance drops during resizing or when copying large shared arrays, and memory inefficiencies in uncontrolled growth scenarios.

When you write $array[] = $value; in PHP, it feels effortless — a simple way to append data to an array. But beneath that clean syntax lies a complex and highly optimized system rooted in PHP’s internal engine, Zend Engine. Understanding how PHP handles array appending under the hood reveals insights into performance, memory management, and design trade-offs.

Let’s take a deep dive into what happens when you append to an array in PHP — from the userland syntax down to the C-level implementation in the Zend Engine.

How PHP Arrays Work Internally

Despite being called “arrays,” PHP arrays are actually ordered hash maps (or dictionaries). They can have integer or string keys, support mixed types, and maintain insertion order. This flexibility comes from their implementation as hashtables in the Zend Engine.

Each PHP array is represented by the HashTable structure in C. This structure contains:

• A bucket array (the actual storage)
• Hash function and lookup logic
• Metadata like size, number of elements, and collision chains

When you append using $array[] = $value;, PHP interprets this as “insert with the next available integer key,” starting from 0 and incrementing automatically.

Step-by-Step: What Happens on $array[] = $value

1. Zend Engine Receives the Opcode When PHP compiles your script, $array[] = $value translates into an opcode like ASSIGN_DIM or ADD_ARRAY_ELEMENT, depending on context. The executor then calls the appropriate handler.

2. Check if the Array is Writeable PHP checks whether the array is a reference or shared (via copy-on-write). If the array has a refcount > 1, it will be copied before modification to preserve data integrity (known as separation).

3. Determine the Next Integer Key The Zend Engine scans the array to find the highest consecutive integer key currently in use. It then uses max(key) 1 as the new key — unless the array is empty, in which case it starts at 0.

   Note: This scan is not linear. PHP caches the next free element in the HashTable structure (nNextFreeElement) to avoid scanning every time.

4. Insert the Value into the HashTable The engine prepares a Bucket (the structure holding key, value, and hash chain pointers), fills it with:

   • The calculated integer key
   • A zval container for the value (which may be duplicated if needed) Then inserts it into the hash table using internal hash functions.

5. Handle HashTable Resizing (if needed) If the bucket array is full (based on nNumOfElements vs. nTableSize), PHP resizes the HashTable:

   • Allocates a larger bucket array (typically doubling in size)
   • Rehashes all existing elements into the new structure
   • Frees the old bucket array

   This operation is O(n) but happens infrequently due to exponential growth — making average insertions amortized O(1).

Memory Allocation and Performance

PHP uses a smart growth strategy to minimize reallocations:

• HashTable sizes grow in powers of 2 (e.g., 8, 16, 32, ..., up to a threshold)
• When resizing, the new size is the smallest power of 2 greater than 1.5 × current size
• This reduces fragmentation and ensures amortized constant-time inserts

For example:

$array = [];
for ($i = 0; $i < 100000; $i  ) {
    $array[] = $i;
}

This loop performs efficiently because:

• No manual key management
• Cached next key via nNextFreeElement
• Resizing happens only ~17 times (log? growth)

But if you pre-allocate or avoid appending in loops unnecessarily, you can do even better.

Pitfalls and Gotchas

Even though appending looks simple, some behaviors can surprise developers:

1. Non-Sequential Integer Keys

If you manually set a high key like $array[1000] = 'x';, then use $array[] = 'y';, PHP will use 1001 as the next key — even if indices 0–999 are empty.

This is because nNextFreeElement tracks the highest integer key ever used, not the first gap.

2. Performance with Large Arrays

While amortized O(1), each resize can cause a noticeable pause. For performance-critical code, consider:

• Pre-sizing arrays when possible (though PHP doesn’t expose direct control)
• Using SplFixedArray when working with large, integer-indexed data

3. Copy-on-Write Overhead

Appending to an array that's shared (e.g., passed by value) may trigger a full copy:

$a = range(1, 100000);
$b = $a;        // refcount = 2, no copy yet
$b[] = 'new';   // triggers full array duplication!

This makes the append O(n) in this specific case.

Optimizations in Modern PHP (7.4 )

Recent PHP versions have significantly improved array performance:

• Packed Arrays: When an array uses only consecutive integer keys and no string keys, PHP may store it more compactly (similar to a C array), improving cache locality and iteration speed.
• JIT (PHP 8 ): While JIT doesn’t directly speed up array appends, tight loops involving appends benefit from reduced interpreter overhead.
• Improved Hash Functions: Better hashing reduces collisions, improving lookup and insert speed.

You can check if an array is "packed" internally using reflection or low-level tools — though not exposed directly in userland.

Summary

Appending to a PHP array with $array[] = $value involves:

• Efficient key calculation using cached metadata
• Fast insertion via the Zend HashTable
• Amortized O(1) performance thanks to exponential resizing
• Potential overhead from copy-on-write or non-sequential keys

While the syntax is deceptively simple, the underlying mechanism is a carefully tuned balance of flexibility and speed.

So next time you push data into a PHP array, remember: there’s a lot more going on than meets the eye — and it’s mostly working in your favor.

The above is the detailed content of A Deep Dive into PHP's Array Append Mechanisms Under the Hood. For more information, please follow other related articles on the PHP Chinese website!