PHP Arrays — Off-by-One Errors That Null Prices

Every real application deals with lists. A shopping cart holds multiple products. A blog has multiple posts. A user profile stores multiple preferences. If PHP only let you store one value per variable, you'd be writing hundreds of lines just to hold a handful of items — and your code would collapse the moment the list grew or shrank. Arrays are how PHP solves this problem, and they're used in virtually every PHP script ever written.

The specific problem arrays fix is called 'data grouping'. Instead of writing $product1, $product2, $product3 and scrambling to keep track of them all, you write one $products array and let PHP manage the collection for you. You can add to it, remove from it, loop over it, sort it, search it — all with built-in tools PHP provides out of the box.

By the end of this article you'll know how to create all three types of PHP arrays (indexed, associative, and multidimensional), how to read and update values inside them, how to loop through them, and — crucially — the exact mistakes that trip up beginners so you can dodge them from day one.

What PHP Arrays Actually Are — Ordered Hash Maps in Disguise

PHP arrays are ordered hash maps that combine the features of a list, dictionary, and sparse vector into a single data structure. Internally, each array is a HashTable of buckets, where each bucket stores a key-value pair and a link to the next bucket in insertion order. This dual nature — O(1) key lookup via hashing plus O(1) iteration in insertion order — is both their superpower and the root of subtle bugs.

Every array maintains an internal pointer and a linear order of elements, independent of key values. When you append with $arr[] = $val, PHP assigns the next integer key as max(int_keys) + 1, not count($arr). This means after unset() on a non-last element, the next append reuses the highest existing integer key plus one, leaving gaps. Array functions like array_values() re-index to close gaps, but unset() does not — a common source of off-by-one errors in loops that assume contiguous 0-based keys.

Use PHP arrays when you need a flexible, mixed-type collection that preserves insertion order and supports both integer and string keys. They are the default choice for 90% of data structures in PHP applications — from HTTP query parameters to database result sets. However, for large datasets (10k+ elements) or strict typed collections, consider SplFixedArray or array_map/array_filter to avoid the overhead of hash table lookups and the mental cost of tracking key gaps.

Indexed Arrays — A Numbered List PHP Can Remember

An indexed array stores values in numbered slots, starting at position 0. Think of it like a numbered queue at a bakery: the first person is ticket 0, the second is ticket 1, and so on. The number is called the index or key, and the thing stored there is the value.

Why does counting start at 0? It's a convention inherited from low-level computing, and PHP follows it like almost every other language. It trips up beginners exactly once — then you never forget it.

You create an indexed array using the square-bracket syntax (preferred in modern PHP) or the older array() function. Both work, but square brackets are cleaner and what you'll see in professional codebases today.

To get a value out, you write the variable name followed by the index in square brackets: $fruits[0] gives you the first item. To add a new item to the end, use $fruits[] = 'mango' — the empty brackets tell PHP to append automatically. You don't need to know what the next index number is; PHP figures it out.

Beyond basic operations, you'll often need to extract portions of an array. array_slice() returns a subset without modifying the original. array_splice() removes a portion and optionally replaces it — it modifies the original. array_chunk() splits an array into groups of a given size, handy for pagination.

<?php

namespace io\thecodeforge\array;

// Create an indexed array of fruit names
// PHP automatically assigns index 0, 1, 2 to each item
$fruits = ['apple', 'banana', 'cherry'];

// Access the first item — remember, counting starts at 0!
echo $fruits[0]; // apple
echo "\n";

// Access the third item using index 2
echo $fruits[2]; // cherry
echo "\n";

// Add a new item to the END of the array
// Empty [] tells PHP: 'put this at the next available index'
$fruits[] = 'mango';

// Count how many items are in the array
$totalFruits = count($fruits);
echo "Total fruits: " . $totalFruits; // 4
echo "\n";

// Loop through every item using a foreach loop
// $fruit (singular) is a temporary variable that holds each item one-by-one
foreach ($fruits as $fruit) {
    echo "- " . $fruit . "\n";
}

// Update an existing item — overwrite index 1
$fruits[1] = 'blueberry';
echo "Updated index 1: " . $fruits[1]; // blueberry
echo "\n";

// Print the full array structure for debugging
print_r($fruits);

// --- Additional: array_slice, array_splice, array_chunk ---
$numbers = [1, 2, 3, 4, 5];
$subset = array_slice($numbers, 1, 3); // [2, 3, 4]
print_r($subset);

array_splice($numbers, 2, 1, ['a', 'b']); // replaces element at index 2
print_r($numbers); // [1, 2, 'a', 'b', 4, 5]

$chunks = array_chunk([1,2,3,4,5,6], 2);
print_r($chunks); // [[1,2], [3,4], [5,6]]

Associative Arrays — Give Your Data a Meaningful Label

An indexed array is great for ordered lists, but what if you want to store a person's profile? You'd need to remember that index 0 is the name, index 1 is the email, index 2 is the age — and that's a disaster waiting to happen.

Associative arrays solve this by letting you choose your own keys instead of relying on numbers. Think of it like a form with labelled fields: 'Name: Sarah', 'Email: sarah@example.com', 'Age: 28'. Each label (key) maps directly to its value. This is how PHP stores structured data — user records, configuration settings, API responses.

You create an associative array using the same square-bracket syntax, but you define the key explicitly using the => arrow operator. On the left of => is the key (a string), on the right is the value.

Associative arrays are the backbone of most real PHP applications. When PHP reads a submitted HTML form, it hands you the data as an associative array in $_POST. When you decode a JSON API response, you get an associative array. When you fetch a database row with PDO, it comes back as an associative array. You'll use these constantly.

Two legacy functions worth knowing: compact() creates an associative array from variable names, and extract() does the reverse (but is notorious for security issues and should be avoided). For modern code, just build arrays manually.

<?php

namespace io\thecodeforge\array;

// Create an associative array to store a user's profile
// The string on the LEFT of => is the key
// The value on the RIGHT of => is what's stored
$userProfile = [
    'name'    => 'Sarah',
    'email'   => 'sarah@example.com',
    'age'     => 28,
    'country' => 'Canada'
];

// Access a value using its KEY — no index numbers needed
echo $userProfile['name'];    // Sarah
echo "\n";
echo $userProfile['email'];   // sarah@example.com
echo "\n";

// Update a value — same syntax, just assign a new value
$userProfile['age'] = 29;
echo "Updated age: " . $userProfile['age']; // 29
echo "\n";

// Add a brand new key-value pair at any time
$userProfile['role'] = 'editor';

// Loop through an associative array using foreach
// $key holds the label, $value holds the data
foreach ($userProfile as $key => $value) {
    echo $key . ': ' . $value . "\n";
}

// Check if a specific key EXISTS before using it
// This prevents errors when data might be missing
if (array_key_exists('email', $userProfile)) {
    echo "Email is set: " . $userProfile['email'] . "\n";
}

// Get all keys as a separate array
$profileKeys = array_keys($userProfile);
print_r($profileKeys);

// --- compact and extract (use with caution) ---
$name = 'John';
$email = 'john@example.com';
$arr = compact('name', 'email');
print_r($arr); // ['name'=>'John', 'email'=>'john@example.com']

// extract($arr); // creates $name, $email variables - security risk, avoid

Multidimensional Arrays — Arrays Inside Arrays

So far each array has stored simple values — strings and numbers. But what if you want to store a list of users, and each user has their own profile data? You put arrays inside arrays. That's a multidimensional array, and it's less scary than it sounds.

Think of a spreadsheet. Each row is a user, each column is a piece of data (name, email, age). A multidimensional array works exactly the same way: the outer array is the list of rows, and each inner array is one row of data.

To access a value, you chain square brackets: $users[0]['name'] means 'go to the first user (index 0), then get the name key from their profile'. It reads left-to-right, outer-to-inner.

Multidimensional arrays are everywhere in PHP. Database query results return as an array of associative arrays. JSON from an API decodes into nested arrays. Shopping cart data is a list of product arrays. Once you're comfortable with one level of nesting, the rest follows the exact same logic — just add another bracket.

For deep nesting, PHP provides array_walk_recursive() which visits every leaf, and array_map_recursive() (custom function). But deep nested structures often benefit from being modeled as objects for clarity.

<?php

namespace io\thecodeforge\array;

// A list of users — each user is its own associative array
// The outer array uses automatic numeric indexes (0, 1, 2)
$users = [
    [
        'name'  => 'Alice',
        'email' => 'alice@example.com',
        'role'  => 'admin'
    ],
    [
        'name'  => 'Bob',
        'email' => 'bob@example.com',
        'role'  => 'editor'
    ],
    [
        'name'  => 'Carol',
        'email' => 'carol@example.com',
        'role'  => 'viewer'
    ]
];

// Access a single value — outer index first, then inner key
// Read as: "user at position 0, then their name"
echo $users[0]['name'];  // Alice
echo "\n";

// Access Bob's email: position 1, key 'email'
echo $users[1]['email']; // bob@example.com
echo "\n";

// Loop through all users and display a formatted summary
foreach ($users as $index => $user) {
    // $index is the numeric position (0, 1, 2)
    // $user is the full associative array for that person
    echo "User #" . ($index + 1) . ": " . $user['name'];
    echo " (" . $user['role'] . ")\n";
}

// Add a brand new user to the list
$users[] = [
    'name'  => 'Dave',
    'email' => 'dave@example.com',
    'role'  => 'editor'
];

echo "\nTotal users after adding Dave: " . count($users) . "\n";

// Update a nested value — change Carol's role
$users[2]['role'] = 'admin';
echo "Carol's new role: " . $users[2]['role'] . "\n";

// --- Using array_walk_recursive to flatten strings ---
$nested = ['a', ['b', 'c'], ['d', ['e']]];
$flat = [];
array_walk_recursive($nested, function($v) use (&$flat) { $flat[] = $v; });
print_r($flat); // ['a','b','c','d','e']

The Most Useful PHP Array Functions You'll Actually Use

PHP ships with over 70 built-in array functions. You don't need to memorise all of them — but a handful come up in almost every project. Knowing these saves you from writing loops by hand for tasks PHP already solved.

Here's the honest shortlist: count() tells you how many items are in an array. in_array() checks whether a value exists anywhere in an array. array_push() adds items to the end (though the [] shorthand is more common). array_pop() removes and returns the last item. array_merge() combines two arrays into one. array_filter() removes items that don't pass a test. array_map() transforms every item using a function. sort() sorts an indexed array alphabetically or numerically. ksort() sorts an associative array by its keys.

The most important mental model: some functions return a new array (array_map, array_filter, array_merge) while others modify the original array in place (sort, ksort, array_push). This distinction matters — if you expect a sorted copy but get NULL because you forgot to use the return value, you'll be confused for longer than you should be.

Additional functions: array_sum() and array_product() compute totals directly. array_reduce() is the Swiss Army knife for reducing an array to any single value (sum, join, maximum). array_column() extracts a column from a multidimensional array, very handy from database results.

<?php

namespace io\thecodeforge\array;

$temperatures = [22, 18, 31, 15, 27, 9, 34];

// --- count() ---
// Returns the total number of items
echo "Days recorded: " . count($temperatures) . "\n"; // 7

// --- in_array() ---
// Returns true if the value exists somewhere in the array
if (in_array(31, $temperatures)) {
    echo "31 degrees was recorded\n";
}

// --- sort() ---
// Sorts the array in place, lowest to highest
// WARNING: this MODIFIES the original array — it does NOT return a new one
sort($temperatures);
echo "Sorted temperatures: ";
echo implode(', ', $temperatures) . "\n"; // 9, 15, 18, 22, 27, 31, 34

// --- array_filter() ---
// Keeps only the items where the callback returns true
// Does NOT modify the original — returns a NEW array
$hotDays = array_filter($temperatures, function($temp) {
    return $temp >= 25; // Keep only temperatures 25 and above
});
echo "Hot days (25+): ";
echo implode(', ', $hotDays) . "\n"; // 27, 31, 34

// --- array_map() ---
// Transforms EVERY item using a function — returns a NEW array
$celsiusTemps = [0, 20, 37, 100];
$fahrenheitTemps = array_map(function($celsius) {
    return ($celsius * 9/5) + 32; // Convert Celsius to Fahrenheit
}, $celsiusTemps);
echo "Fahrenheit: ";
echo implode(', ', $fahrenheitTemps) . "\n"; // 32, 68, 98.6, 212

// --- array_merge() ---
// Combines two arrays into one new array
$morningReadings = [18, 19, 21];
$afternoonReadings = [28, 31, 29];
$allReadings = array_merge($morningReadings, $afternoonReadings);
echo "All readings: ";
echo implode(', ', $allReadings) . "\n"; // 18, 19, 21, 28, 31, 29

// --- array_pop() ---
// Removes AND returns the last item — modifies the original array
$lastReading = array_pop($allReadings);
echo "Removed last reading: " . $lastReading . "\n"; // 29
echo "Remaining count: " . count($allReadings) . "\n"; // 5

// --- Additional: array_sum, array_product, array_reduce, array_column ---
$values = [1, 2, 3, 4];
echo "Sum: " . array_sum($values) . "\n"; // 10
echo "Product: " . array_product($values) . "\n"; // 24

$reduced = array_reduce($values, function($carry, $item) {
    return $carry . '-' . $item;
}, 'start');
echo "Reduced: " . $reduced . "\n"; // start-1-2-3-4

$users = [
    ['id' => 1, 'name' => 'Alice'],
    ['id' => 2, 'name' => 'Bob'],
];
$names = array_column($users, 'name');
print_r($names); // ['Alice', 'Bob']

PHP Array Functions Quick Reference Table

Here is a quick reference table of the most commonly used PHP array functions. Keep this handy while coding.

Keep in mind that the $strict parameter for in_array and array_search defaults to false (loose comparison). Always pass true unless you intentionally need type coercion.

Also: array_sum and array_product are O(n) but very fast. array_column is a gem for extracting columns from multidimensional arrays.

Array Destructuring — Extract Array Values into Variables

PHP's array destructuring (or unpacking) lets you assign array elements directly to variables in one statement. This is a clean alternative to manual indexing and is especially useful when working with functions that return arrays, like database fetches or pathinfo().

PHP offers two syntaxes: the classic list() function (available since PHP 4) and the shorter square bracket syntax (since PHP 7.1). Both do the same thing, but the [] syntax is now preferred for its brevity and clarity.

Destructuring works with both indexed and associative arrays. For indexed arrays, PHP assigns variables in order starting from index 0. For associative arrays, you specify the key as the variable name, making it extremely readable.

One common gotcha: list() only assigns from numeric indices by default. To destructure associative arrays, you must use the [] syntax with named keys (PHP 7.1+). Also, you can skip elements by leaving a blank — [, $b, , $d] = $arr — which is great when you only need specific items.

Nested destructuring works too: [$a, [$b, $c]] = $arr.

<?php

namespace io\thecodeforge\array;

// Indexed array destructuring
$fruits = ['apple', 'banana', 'cherry'];

// Using list() — older syntax
list($first, $second, $third) = $fruits;
echo "$first, $second, $third\n"; // apple, banana, cherry

// Using [] syntax (PHP 7.1+) — cleaner
[$first, $second, $third] = $fruits;
echo "$first, $second, $third\n"; // apple, banana, cherry

// Associative array destructuring (PHP 7.1+)
$user = ['name' => 'Sarah', 'email' => 'sarah@example.com', 'age' => 28];
['name' => $name, 'email' => $email] = $user;
echo "Name: $name, Email: $email\n";

// Skipping elements
$data = [10, 20, 30, 40];
[, $b, , $d] = $data;
echo "b: $b, d: $d\n"; // b: 20, d: 40

// Destructuring in foreach loops
$people = [
    ['Alice', 30],
    ['Bob', 25],
];
foreach ($people as [$name, $age]) {
    echo "$name is $age years old.\n";
}

// Nested destructuring
$data = [
    'user' => [
        'name' => 'Carol',
        'address' => ['city' => 'Vancouver', 'zip' => 'V6B']
    ]
];
['user' => ['name' => $name, 'address' => ['city' => $city]]] = $data;
echo "$name lives in $city\n"; // Carol lives in Vancouver

// Using list() with associative (not directly supported)
// list($name, $email) = $user; // won't work for associative

Sorting Arrays in PHP (sort, rsort, ksort, usort)

PHP provides many sorting functions to arrange array elements in a specific order. The key is choosing the right function for your array type and desired outcome.

For indexed arrays, sort() sorts in ascending order, and rsort() sorts in descending order. Both discard existing keys and re-index numerically. This is fine when you don't care about preserving the original keys.

For associative arrays, ksort() sorts by key (ascending) and krsort() by key (descending), preserving key-value associations. asort() sorts by value (ascending) and arsort() by value (descending), also preserving keys. These are essential when you need to maintain logical relationships (e.g., sorting a user array by name while keeping each person's full data intact).

For custom sorting logic, usort() accepts a user-defined comparison function. You can sort by any criteria — by the length of a string, by a nested property, or by a computed value. The comparison function must return an integer less than, equal to, or greater than zero.

All sorting functions modify the array in place and return a boolean. They do not return a sorted copy. The only way to keep the original order is to clone the array first: $sorted = $arr; sort($sorted);.

For stable sorting, use uasort() and uksort() for associative arrays with custom comparison.

<?php

namespace io\thecodeforge\array;

// Indexed arrays — sort() and rsort()
$numbers = [3, 1, 4, 1, 5, 9];
sort($numbers); // ascending
echo "Sorted: " . implode(', ', $numbers) . "\n"; // 1, 1, 3, 4, 5, 9

$numbers = [3, 1, 4, 1, 5, 9];
rsort($numbers); // descending
echo "Reverse sorted: " . implode(', ', $numbers) . "\n"; // 9, 5, 4, 3, 1, 1

// Associative arrays — ksort(), asort(), etc.
$inventory = [
    'apple'  => 5,
    'banana' => 2,
    'cherry' => 8
];

ksort($inventory); // sort by key (alphabetical)
print_r($inventory);
/*
Array
(
    [apple] => 5
    [banana] => 2
    [cherry] => 8
)
*/

$inventory = [
    'apple'  => 5,
    'banana' => 2,
    'cherry' => 8
];
asort($inventory); // sort by value (ascending)
print_r($inventory);
/*
Array
(
    [banana] => 2
    [apple] => 5
    [cherry] => 8
)
*/

// Custom sorting with usort()
$people = [
    ['name' => 'Alice', 'age' => 30],
    ['name' => 'Bob', 'age' => 25],
    ['name' => 'Carol', 'age' => 35]
];

usort($people, function($a, $b) {
    return $a['age'] <=> $b['age']; // spaceship operator: -1, 0, 1
});

foreach ($people as $person) {
    echo $person['name'] . ' is ' . $person['age'] . " years old\n";
}

// Preserving original — always copy first
$original = [3, 1, 4];
$sorted = $original;
sort($sorted);
echo "Original: " . implode(', ', $original) . "\n"; // 3, 1, 4
echo "Sorted copy: " . implode(', ', $sorted) . "\n"; // 1, 3, 4

// Stable sorting with uasort (preserves key-value)
$inventory = ['apple'=>5, 'banana'=>2, 'cherry'=>8];
uasort($inventory, function($a, $b) {
    return $a <=> $b;
});
print_r($inventory); // keys preserved: banana, apple, cherry

Spread Operator in Arrays (PHP 7.4+)

Introduced in PHP 7.4, the spread operator (...) allows you to unpack an array into another array. This is similar to array_merge() but with a cleaner syntax and better performance in some cases.

You use it inside a new array literal by prefixing the array variable with .... All values from the spread array are copied at that position. You can use the spread operator multiple times and combine it with regular elements.

One important behaviour: the spread operator only works with arrays and objects that implement Traversable (like ArrayIterator). It does not work with strings or non-traversable objects.

Another difference from array_merge(): with string keys, the spread operator behaves identically — later keys overwrite earlier ones. With integer keys, array_merge() re-indexes them starting from 0, while the spread operator preserves integer keys from the source array (and if there's a conflict, the later key overwrites the earlier one, just like string keys). This subtle difference matters when merging indexed arrays where you want to keep original indices.

<?php

namespace io\thecodeforge\array;

// Basic unpacking into a new array
$parts = [2, 3];
$numbers = [1, ...$parts, 4, 5];
echo implode(', ', $numbers) . "\n"; // 1, 2, 3, 4, 5

// Multiple spreads
$first = ['a', 'b'];
$second = ['c', 'd'];
$combined = [...$first, ...$second, 'e'];
echo implode(', ', $combined) . "\n"; // a, b, c, d, e

// With associative arrays — later keys overwrite earlier ones
$defaults = ['timeout' => 30, 'retries' => 3];
$overrides = ['retries' => 5, 'debug' => true];
$config = [...$defaults, ...$overrides];
print_r($config);
/*
Array
(
    [timeout] => 30
    [retries] => 5
    [debug] => 1
)
*/

// Spread vs array_merge for indexed arrays with explicit keys
$a = [1 => 'x', 2 => 'y'];
$b = [2 => 'z'];

$merged = array_merge($a, $b);
print_r($merged); // [0=>'x', 1=>'y', 2=>'z'] — re-indexed all

$spread = [...$a, ...$b];
print_r($spread); // [1=>'x', 2=>'z'] — key 2 overwritten

Practice Exercises: Test Your PHP Array Skills

Apply what you've learned with these five real-world exercises. Each exercise comes with a description, hints, and the expected output. Try to solve each one without peeking at the solution code first.

Exercise 1: Shopping Cart Manipulation You have an array of product names in a cart. Write a function that adds a product to the cart, removes a product by name, and returns the updated cart. Assume products can appear multiple times (different quantities), but for this exercise each product appears once. Use array_push or [] to add, array_search to find the position, and unset plus array_values to re-index.

Exercise 2: Grade Sorter Given an associative array of student names and their integer grades (e.g., ['Alice' => 85, 'Bob' => 92, 'Carol' => 78]), sort the array by grade in descending order while preserving the student names as keys. Use arsort(). Then display each student's name and grade.

Exercise 3: Array Deduplication Write a function that removes duplicate values from an array while keeping the first occurrence of each value. Use array_unique(). Test with a mix of integers and strings (with loose comparison issues). Then write a version that uses strict comparison. Compare results.

Exercise 4: Nested Array Flattening Write a recursive function that flattens a multidimensional array into a single-level indexed array. For example, [1, [2, [3, 4]], 5] becomes [1, 2, 3, 4, 5]. Do not use array_merge_recursive — implement it manually using a foreach loop and recursion.

Exercise 5: Array Partitioning Given an array of numbers, partition it into two arrays: one with even numbers and one with odd numbers. Use array_filter() with a callback or manually loop. Then output both arrays.

Bonus Exercise: Rotate Array Write a function that rotates an array by a given number of positions. For example, rotate([1,2,3,4,5], 2) gives [4,5,1,2,3]. Use array_slice and array_merge.

```php <?php // --- Exercise 1: Shopping Cart --- $cart = ['apple', 'banana', 'cherry']; function addProduct(array $cart, string $product): array { $cart[] = $product; return $cart; } function removeProduct(array $cart, string $product): array { $index = array_search($product, $cart, true); if ($index !== false) { unset($cart[$index]); $cart = array_values($cart); // re-index } return $cart; } $cart = addProduct($cart, 'date'); $cart = removeProduct($cart, 'banana'); print_r($cart); // ['apple', 'cherry', 'date']

// --- Exercise 2: Grade Sorter --- $grades = ['Alice' => 85, 'Bob' => 92, 'Carol' => 78]; arsort($grades); foreach ($grades as $name => $grade) { echo "$name: $grade "; } // Bob: 92 // Alice: 85 // Carol: 78

// --- Exercise 3: Deduplication --- $data = [1, 2, 2, 3, '2', 4, 4]; $uniqueLoose = array_unique($data); // loose comparison $strictUnique = []; foreach ($data as $value) { if (!in_array($value, $strictUnique, true)) { $strictUnique[] = $value; } } print_r($uniqueLoose); print_r($strictUnique);

// --- Exercise 4: Flatten --- function flatten(array $arr): array { $result = []; foreach ($arr as $item) { if (is_array($item)) { $result = array_merge($result, flatten($item)); } else { $result[] = $item; } } return $result; } $nested = [1, [2, [3, 4]], 5]; print_r(flatten($nested)); // [1,2,3,4,5]

// --- Exercise 5: Partition --- $numbers = [1, 2, 3, 4, 5, 6]; $even = []; $odd = []; foreach ($numbers as $num) { if ($num % 2 == 0) { $even[] = $num; } else { $odd[] = $num; } } echo "Even: " . implode(', ', $even) . " "; echo "Odd: " . implode(', ', $odd) . " ";

// Bonus: Rotate function rotate(array $arr, int $positions): array { $positions = $positions % count($arr); $slice = array_slice($arr, -$positions); $remainder = array_slice($arr, 0, count($arr) - $positions); return array_merge($slice, $remainder); } print_r(rotate([1,2,3,4,5], 2)); // [4,5,1,2,3] ```

Try these exercises before reviewing the solution code. They will reinforce the array functions, sorting, destructuring, and traversal patterns covered in this article.

Array Traversal and Mutation Pitfalls

Looping over an array while modifying it leads to surprising bugs. The classic example is using foreach ($arr as &$value) — the reference persists after the loop ends, and any subsequent assignment to that variable modifies the array.

Another trap: calling unset() on an element inside a foreach loop can skip the next element or cause undefined behaviour depending on how the loop tracks the internal array pointer. PHP's foreach operates on a copy of the array by default, so unsetting inside the loop doesn't break the iteration — but it can confuse readers.

Using array_shift() or array_pop() inside a loop is also dangerous because they reset the internal pointer. If you need to remove items during iteration, collect the keys first with array_keys(), then remove them after the loop.

Also, after unsetting elements, the array remains sparse. Use array_values() to re-index if you need contiguous numeric keys.

<?php

namespace io\thecodeforge\array;

// Pitfall 1: foreach with &$value reference persists
$items = ['a', 'b', 'c'];
foreach ($items as &$value) {
    $value = strtoupper($value);
}
// $value still references $items[2]!
$value = 'OVERRIDE'; // modifies $items[2] to 'OVERRIDE'
print_r($items); // ['A', 'B', 'OVERRIDE']

// Fix: unset($value) after the loop
unset($value);

// Pitfall 2: unset inside foreach - keys preserved but can confuse
$arr = [1, 2, 3, 4, 5];
foreach ($arr as $key => $val) {
    if ($val % 2 == 0) {
        unset($arr[$key]);
    }
}
print_r($arr); // [0=>1, 2=>3, 4=>5]

// Pitfall 3: array_shift inside loop re-indexes
$queue = ['x', 'y', 'z'];
while ($item = array_shift($queue)) {
    echo $item . ' ';
}
echo "\n";
// $queue is now empty

// Use array_values after unset to re-index
$arr = [0=>'a', 2=>'b', 4=>'c'];
$arr = array_values($arr);
print_r($arr); // [0=>'a', 1=>'b', 2=>'c']

Type Juggling and Loose Comparison in Arrays

PHP is dynamically typed and famously loose with comparisons. When you use in_array(), array_search(), or array_unique() without strict mode, type coercion can give you false positives or unexpected behaviour.

Example: in_array('1', [1, 2, 3]) returns true because the string '1' is coerced to integer 1 during the loose comparison. This can cause security issues if you're checking user input against a whitelist.

Similarly, array_unique() uses loose comparison by default, so ['1', 1, 2] becomes ['1', 2] — the integer 1 is considered equal to the string '1', and only the first occurrence is kept.

The fix is always to pass the third parameter true for strict comparison: in_array($needle, $haystack, true). For array_unique(), use SORT_REGULAR with the flag SORT_STRING or convert to a consistent type first.

To avoid type juggling altogether, declare strict_types=1 at the top of your PHP files. This forces PHP to throw a TypeError when you pass a string to a function expecting an int, among other things.

<?php

namespace io\thecodeforge\array;

// Loose comparison: string '1' matches integer 1
$haystack = [1, 2, 3];
var_dump(in_array('1', $haystack));           // bool(true) - loose
var_dump(in_array('1', $haystack, true));     // bool(false) - strict

// array_unique with loose vs strict
$mixed = ['1', 1, 2, '2', 3];
$uniqueLoose = array_unique($mixed);
print_r($uniqueLoose); // [0=>'1', 2=>2, 4=>3]

$uniqueStrict = array_unique($mixed, SORT_STRING);
print_r($uniqueStrict); // all kept

// array_keys with loose search
$user = ['name' => 'Sarah', 'role' => '1'];
$keys = array_keys($user, 1, false); // loose: finds 'role'
print_r($keys); // [0=>'role']

// Using strict_types
// If you uncomment the following, the string '1' will not be cast to int
// declare(strict_types=1);
// function foo(int $x) { return $x; }
// echo foo('1'); // TypeError in strict mode

Array Walk and Reduce — Advanced Iteration

Beyond foreach, PHP offers two powerful iteration functions: array_walk() and array_reduce().

array_walk($arr, $callback) applies a callback to each element, modifying the array in place if the callback uses a reference. Unlike array_map, which returns a new array, array_walk doesn't return an array — it returns true on success. Use it when you need to mutate the original or when the callback doesn't produce a return value.

array_reduce($arr, $callback, $initial) iteratively reduces the array to a single value. The callback receives a carry (accumulator) and the current item. The initial value is used as the first carry. It's like a left fold in functional programming.

Both functions are part of PHP's functional programming toolkit, but they're more verbose than foreach for simple cases. Use them when you want to express intent clearly or when chaining transformations.

<?php

namespace io\thecodeforge\array;

// array_walk modifies in place
$names = ['Alice', 'Bob', 'Carol'];
array_walk($names, function(&$value, $key) {
    $value = strtoupper($value);
});
print_r($names); // ['ALICE', 'BOB', 'CAROL']

// array_reduce: sum
$numbers = [1, 2, 3, 4];
$sum = array_reduce($numbers, function($carry, $item) {
    return $carry + $item;
}, 0);
echo "Sum: $sum\n"; // 10

// array_reduce: product
$product = array_reduce($numbers, function($carry, $item) {
    return $carry * $item;
}, 1);
echo "Product: $product\n"; // 24

// array_reduce: find max
$max = array_reduce($numbers, function($carry, $item) {
    return max($carry, $item);
}, PHP_INT_MIN);
echo "Max: $max\n"; // 4

// array_reduce with associative array: group by first letter
$names = ['Alice', 'Bob', 'Charlie'];
$grouped = array_reduce($names, function($carry, $name) {
    $letter = $name[0];
    $carry[$letter][] = $name;
    return $carry;
}, []);
print_r($grouped); // ['A'=>['Alice'], 'B'=>['Bob'], 'C'=>['Charlie']]

PHP Array Performance: Big O and Memory

Not all array operations are created equal. Understanding the time complexity of common operations helps you avoid slow code.

• count() is O(1) — PHP caches the array length.
• Accessing by key/index is O(1) — PHP arrays are hash tables.
• in_array() is O(n) — it scans the entire array. For large lookups, use array_flip() to create a hash map first.
• array_search() is O(n) — same as in_array.
• sort() is O(n log n) — Quicksort implementation.
• array_push() is O(1) amortized.
• array_shift() is O(n) — it re-indexes all numeric keys.
• array_unshift() is O(n) — same reason.
• array_unique() is O(n log n) due to sorting.

Memory: PHP arrays are memory-heavy. Each entry consumes ~144 bytes for an integer value, more for strings. For large datasets (millions of elements), consider SplFixedArray which uses a C array internally and is much more memory efficient.

<?php

namespace io\thecodeforge\array;

// Example: using array_flip for fast lookups
$haystack = range(1, 100000);
$lookup = array_flip($haystack); // now keys are the values

// O(1) check if 50000 exists
if (isset($lookup[50000])) {
    echo "Found\n";
}

// SplFixedArray for memory efficiency
$size = 1000000;
$fixed = new \SplFixedArray($size);
for ($i = 0; $i < $size; $i++) {
    $fixed[$i] = $i;
}
echo "Memory used for SplFixedArray: " . memory_get_usage(true) . " bytes\n";

// Compare with regular array
$regular = [];
for ($i = 0; $i < $size; $i++) {
    $regular[$i] = $i;
}
echo "Memory used for regular array: " . memory_get_usage(true) . " bytes\n";

Creating Arrays the Right Way — array() vs []

When you need a container, you have two options: the old array() syntax or the short []. There's no performance difference. PHP parses both into the same internal hash map. The choice is readability and muscle memory.

Short syntax wins in modern PHP. It's cleaner for nested structures. It matches JSON. It signals you're writing current code, not legacy PHP 4.

But here's the trap: trailing commas. PHP 7.3+ lets you add a trailing comma in function calls. PHP 8.0+ extends that to arrays. Use it. When you add an element later, you change one line instead of two. Your diff stays clean.

When initializing, prefer empty brackets for an empty array: $items = []. Then push with $items[] = $value. Avoid array() — it's visual noise.

// io.thecodeforge

// Old way — don't
$users = array('alice', 'bob', 'charlie');

// Modern way — do
$users = ['alice', 'bob', 'charlie',]; // trailing comma: safe in PHP 8.x

// Empty array
$logs = [];

// Nested — short syntax wins
$config = [
    'database' => [
        'host' => 'localhost',
        'port' => 3306,
    ],
    'cache' => [
        'driver' => 'redis',
    ],
];

Adding and Removing Elements Without Losing Your Mind

Adding elements seems trivial until you accidentally overwrite data or introduce gaps. Here's the brutal truth: PHP gives you tools that look similar but behave differently.

To append, use $array[] = $value. It picks the next numeric key automatically. But only for numeric keys. If your array has string keys, [] appends at the next numeric index, leaving your associative data untouched. That's usually a bug.

For associative arrays, always use explicit assignment: $array['key'] = $value. Don't trust autovivification.

Removing elements is where juniors get burned. unset($array[3]) removes the element but leaves the key. 99% of the time you want array_splice() — it re-indexes numeric keys. For associative arrays, unset() is fine because key order doesn't matter.

array_pop() removes the last element. array_shift() removes the first and re-indexes. Both modify the original array. They're not pure functions.

// io.thecodeforge

$items = ['a', 'b', 'c'];

// Append — correct
$items[] = 'd'; // ['a', 'b', 'c', 'd']

// Remove index 1 without re-indexing (WRONG)
unset($items[1]); // ['a', 'c', 'd'] — key 2 still exists!

// Remove index 1 with re-indexing (RIGHT)
$items = ['a', 'b', 'c'];
array_splice($items, 1, 1); // ['a', 'c'] — keys reset to 0, 1

// Associative — use unset
$user = ['id' => 42, 'name' => 'alice'];
unset($user['name']); // ['id' => 42] — no re-index needed

// Pop and shift — modify in place
$last = array_pop($items);    // items = ['a'], last = 'c'
$first = array_shift($items); // items = [], first = 'a'