How to Delete an Element from an Array in PHP

By the end of this page, you will understand how PHP arrays store elements, why setting a value to null does not remove the array entry, and how to properly delete elements using unset(). You will also learn when to reindex an array, when to use array_filter(), and what common mistakes to avoid.

PHP arrays are associative data structures that map keys to values. Even when you use numeric indexes like 0, 1, and 2, PHP still treats the array as key-value storage.

That detail explains the core issue:

• Setting an element to null changes its value to null
• It does not remove the key from the array
• So the element still exists and can still be visited by foreach

To actually delete an element from a PHP array, use unset():

unset($array[1]);

This removes the key-value pair entirely.

Why this matters in real programming:

• You may need to remove invalid items from a list
• You may want to skip deleted records in loops
• You may need to clean user input before processing it
• You may want arrays to reflect current state accurately

Understanding the difference between changing a value and removing an element is essential when working with collections in PHP.

Think of a PHP array like a set of labeled boxes on a shelf.

• The key is the label on the box
• The value is what is inside the box

If you set a box's contents to null, the box is still on the shelf with its label.

If you use unset(), you remove the whole box from the shelf.

A foreach loop walks past every box that still exists. It does not care whether the box contains null, a string, or a number. If the box is still there, foreach can include it.

Remove one element with unset()

$array = ['a', 'b', 'c'];
unset($array[1]);

foreach ($array as $value) {
    echo $value . PHP_EOL;
}

Output:

a
c

Here, the element at key 1 is removed completely.

Setting to null does not delete the element

$array = ['a', 'b', 'c'];
$array[1] = null;

foreach ($array as $value) {
    var_dump($value);
}

Output:

string(1) "a"
NULL
string(1) "c"

Consider this example:

$array = ['a', 'b', 'c'];
unset($array[1]);

foreach ($array as $key => $value) {
    echo $key . ': ' . $value . PHP_EOL;
}

Step by step:

1. PHP creates the array:

   • key 0 => 'a'
   • key 1 => 'b'
   • key 2 => 'c'

2. unset($array[1]) removes the entry with key 1 completely.

3. The array now contains:

   • key 0 => 'a'

Removing invalid form inputs

If a user submits a list of values, you may remove empty entries before saving them.

$tags = ['php', '', 'arrays', null];
$tags = array_filter($tags, fn($tag) => $tag !== '' && $tag !== null);

Deleting items from a shopping cart

unset($cart[$productId]);

This removes the product from the cart entirely.

Excluding failed records from batch processing

If a record fails validation, you may remove it before the next processing step.

unset($records[$index]);

Cleaning API response data

Sometimes an API returns placeholder or unwanted values. You can remove them before returning data to the frontend.

Managing configuration arrays

Applications often build configuration arrays dynamically. Removing a key with unset() is cleaner than assigning when the setting should not exist at all.

In real projects, developers often choose between several removal patterns depending on the goal.

1. Direct removal with unset()

Used when you know the exact key to remove.

if (isset($data['debug'])) {
    unset($data['debug']);
}

2. Guard clauses before removal

This avoids notices or makes intent clearer.

if (array_key_exists('temporary_token', $sessionData)) {
    unset($sessionData['temporary_token']);
}

3. Filtering arrays by rule

Useful when removing many elements based on validation.

$users = array_filter($users, fn($user) => $user['active'] === true);

4. Reindexing lists for output

After deleting from a list, developers often reindex before sending JSON or rendering a view.

Mistake 1: Assuming null removes the element

Broken example:

$array = ['a', 'b', 'c'];
$array[1] = null;

This does not remove key 1. It only changes its value.

Correct version:

unset($array[1]);

Mistake 2: Expecting numeric indexes to reset automatically

$array = ['a', 'b', 'c'];
unset($array[1]);
print_r($array);

Result:

Array
(
    [0] => a
    [2] => c
)

If you need sequential indexes, do this:

// Remove one element by key
unset($array[$key]);

// Set value to null (does NOT remove element)
$array[$key] = null;

// Reindex numeric array after deletion
$array = array_values($array);

// Remove empty values by condition
$array = array_filter($array, fn($value) => $value !== null && $value !== '');

Key rules

• PHP arrays are key-value maps
• null means the key still exists with an empty value
• unset() removes the key entirely
• foreach loops over existing elements
• After unset() on numeric arrays, indexes may have gaps
• Use array_values() to reset numeric indexes
• array_filter() preserves keys unless you reindex manually

Useful checks

Why does foreach still include an element set to null in PHP?

Because the array key still exists. Only the value changed to null.

How do I completely remove an array element in PHP?

Use unset($array[$key]);.

Does unset() reset array indexes in PHP?

No. Numeric indexes are preserved, so gaps may remain.

How do I reset array indexes after deleting an element?

Use array_values($array).

Should I use unset() or array_filter()?

Use unset() to remove a known key. Use array_filter() to remove items based on a condition.

What is the difference between isset() and array_key_exists()?

isset() returns false for missing keys and for keys with null values. checks whether the key exists regardless of value.

• unset() — the direct PHP language construct for removing variables and array elements
• PHP arrays — understanding that arrays are key-value maps explains why null does not delete a key
• foreach loops — important for understanding which array elements are iterated
• array_filter() — useful for removing multiple elements based on a rule
• array_values() — helpful for reindexing numeric arrays after deletion
• isset() — commonly used when checking whether an array entry is available
• array_key_exists() — useful when null values are allowed and key existence matters