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.

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.

<?php

// 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);

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.

<?php

// 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)) {\n    echo \"Email is set: \" . $userProfile['email'] . \"\\n\";\n}\n\n// Get all keys as a separate array\n$profileKeys = array_keys($userProfile);\nprint_r($profileKeys);\n",
        "output": "Sarah\nsarah@example.com\nUpdated age: 29\nname: Sarah\nemail: sarah@example.com\nage: 29\ncountry: Canada\nrole: editor\nEmail is set: sarah@example.com\nArray\n(\n    [0] => name\n    [1] => email\n    [2] => age\n    [3] => country\n    [4] => role\n)"
      }

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.

<?php

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

// 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";

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.

<?php

$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)) {\n    echo \"31 degrees was recorded\\n\";\n}\n\n// --- sort() ---\n// Sorts the array in place, lowest to highest\n// WARNING: this MODIFIES the original array — it does NOT return a new one\nsort($temperatures);\necho \"Sorted temperatures: \";\necho implode(', ', $temperatures) . \"\\n\"; // 9, 15, 18, 22, 27, 31, 34\n\n// --- array_filter() ---\n// Keeps only the items where the callback returns true\n// Does NOT modify the original — returns a NEW array\n$hotDays = array_filter($temperatures, function($temp) {\n    return $temp >= 25; // Keep only temperatures 25 and above\n});\necho \"Hot days (25+): \";\necho implode(', ', $hotDays) . \"\\n\"; // 27, 31, 34\n\n// --- array_map() ---\n// Transforms EVERY item using a function — returns a NEW array\n$celsiusTemps = [0, 20, 37, 100];\n$fahrenheitTemps = array_map(function($celsius) {\n    return ($celsius * 9/5) + 32; // Convert Celsius to Fahrenheit\n}, $celsiusTemps);\necho \"Fahrenheit: \";\necho implode(', ', $fahrenheitTemps) . \"\\n\"; // 32, 68, 98.6, 212\n\n// --- array_merge() ---\n// Combines two arrays into one new array\n$morningReadings = [18, 19, 21];\n$afternoonReadings = [28, 31, 29];\n$allReadings = array_merge($morningReadings, $afternoonReadings);\necho \"All readings: \";\necho implode(', ', $allReadings) . \"\\n\"; // 18, 19, 21, 28, 31, 29\n\n// --- array_pop() ---\n// Removes AND returns the last item — modifies the original array\n$lastReading = array_pop($allReadings);\necho \"Removed last reading: \" . $lastReading . \"\\n\"; // 29\necho \"Remaining count: \" . count($allReadings) . \"\\n\"; // 5\n",
        "output": "Days recorded: 7\n31 degrees was recorded\nSorted temperatures: 9, 15, 18, 22, 27, 31, 34\nHot days (25+): 27, 31, 34\nFahrenheit: 32, 68, 98.6, 212\nAll readings: 18, 19, 21, 28, 31, 29\nRemoved last reading: 29\nRemaining count: 5"
      }

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.

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.

<?php

// 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

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);.

<?php

// 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 = [\n    'apple'  => 5,\n    'banana' => 2,\n    'cherry' => 8\n];

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";
}
// Output:
// Bob is 25 years old
// Alice is 30 years old
// Carol is 35 years old

// 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

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

// 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
$arr1 = [10, 20];
$arr2 = [30, 40];

$merged = array_merge($arr1, $arr2);
print_r($merged); // [0=>10, 1=>20, 2=>30, 3=>40] — re-indexed

$spread = [...$arr1, ...$arr2];
print_r($spread); // [0=>10, 1=>20, 2=>30, 3=>40] — same result for simple indexed arrays

// When arrays have explicit integer keys:
$a = [1 => 'x', 2 => 'y'];
$b = [2 => 'z']; // overlap
$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=>'y', 3=>'z'] — preserves original keys, then appends with next available integer
// Note: key 2 from $b conflicts with key 2 from $a, so $b's value 'z' overwrites 'y'? Actually with spread, duplicate integer keys cause overwrite: the later spread source's values win.
// In this case, [...$a, ...$b] means: take $a's [1=>'x', 2=>'y'], then $b's [2=>'z'] overwrites key 2

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.

```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 $uniqueStrict = array_unique($data, SORT_STRING); // strict? Actually SORT_STRING still loose. Use array_values(array_unique($data, SORT_REGULAR))? // The correct way for strict: use manual loop or array_flip trick. // Simplified: array_unique with default (SORT_REGULAR) uses loose; to differentiate, you can use array_keys with strict? // For demonstration: echo "Loose unique: "; print_r($uniqueLoose); // [0=>1, 1=>2, 3=>3, 5=>4] (string '2' is considered equal to integer 2, so only first kept) // Strict: use manual: $strictUnique = []; foreach ($data as $value) { if (!in_array($value, $strictUnique, true)) { $strictUnique[] = $value; } } print_r($strictUnique); // [1,2,3,'2',4] — string '2' kept separate

// --- 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) . " "; // 2,4,6 echo "Odd: " . implode(', ', $odd) . " "; // 1,3,5 ```

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.

<?php

// 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 - unexpected results
$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] - keys are preserved, skipping even numbers works here but can be confusing with numeric reindexing

// Pitfall 3: array_shift inside loop shifts all keys
$queue = ['x', 'y', 'z'];
while ($item = array_shift($queue)) {
    echo $item . ' ';
    // After first iteration, $queue becomes ['y','z'] with keys 0,1
}
echo "\n";
// Works but $queue is now empty - okay for queues but beware of unexpected key renumbering with numeric arrays

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.

<?php

// 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 comparison
$mixed = ['1', 1, 2, '2', 3];
$uniqueLoose = array_unique($mixed);
print_r($uniqueLoose); // [0=>'1', 2=>2, 4=>3] - '1' and 1 merged, '2' and 2 merged

// array_unique with strict flag (SORT_REGULAR is default, but we need SORT_STRING? Actually SORT_REGULAR uses loose too)
// To get strict, use array_unique with SORT_STRING flag
$uniqueStrict = array_unique($mixed, SORT_STRING);
print_r($uniqueStrict); // [0=>'1', 1=>1, 2=>2, 3=>'2', 4=>3] - all kept

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

// Same with strict: $keys = array_keys($user, 1, true); // returns empty because no integer 1 in values