How to Remove Empty Array Elements in PHP

By the end of this page, you will understand why unset($link) does not remove items from the original array during foreach in PHP, and how to correctly remove empty string values. You will also learn when to use unset() with keys, when array_filter() is a better choice, and how to safely clean user input arrays in real projects.

In PHP, a foreach loop gives you each array value one at a time. In this code:

foreach ($linksArray as $link)

$link is just a temporary variable holding the current value. It is not the actual array element itself. So when you call:

unset($link);

PHP only removes the temporary loop variable, not the item inside $linksArray.

To remove an item from the original array, you need access to its key and then unset that key:

foreach ($linksArray as $key => $link) {
    if ($link === '') {
        unset($linksArray[$key]);
    }
}

This matters because cleaning arrays is very common in programming:

• processing form input
• removing blank fields
• validating API request data
• preparing database values
• sanitizing configuration arrays

There is also an important difference between checking for an and checking for a value PHP considers .

Think of foreach like handing you a copy of a note from a list.

• $linksArray is the full list on the wall.
• $link is the note currently handed to you.
• unset($link) throws away the note in your hand.
• The original note on the wall is still there.

If you want to remove the real item from the list, you must know its position and erase it from the list itself:

• $key tells you where the item is
• unset($linksArray[$key]) removes it from the real array

So the key idea is:

• unsetting the loop variable does not modify the source array
• unsetting the array element by key does

Remove empty strings with foreach and unset

foreach ($linksArray as $key => $link) {
    if ($link === '') {
        unset($linksArray[$key]);
    }
}

Why this works

• $key is the array index
• $link is the current value
• unset($linksArray[$key]) removes the real element from the array

Example

$linksArray = ['google.com', '', 'example.com', ''];

foreach ($linksArray as $key => $link) {
    if ($link === '') {
        unset($linksArray[]);
    }
}

();

Trace example

$linksArray = ['A', '', 'B'];

foreach ($linksArray as $key => $link) {
    if ($link === '') {
        unset($linksArray[$key]);
    }
}

print_r($linksArray);

Step by step

1. Initial array

['A', '', 'B']

Keys are:

• 0 => 'A'
• 1 => ''
• 2 => 'B'

2. First loop iteration

• $key is 0
• $link is 'A'

Removing empty array elements is common when working with user-provided data.

Form submissions

A form may allow users to enter multiple links, tags, or phone numbers. Some fields may be left blank:

$links = ['https://a.com', '', 'https://b.com'];

Before saving them, you remove empty values.

API request cleanup

An API may receive optional fields as empty strings. You often filter those out before validation or storage.

Search filters

A search form may submit some filters as blank values. Removing empty entries makes the query-building logic simpler.

CSV or imported data

When reading rows from files, some columns may contain empty strings. Filtering helps normalize the data.

Settings and configuration arrays

A config array may contain optional values that should be ignored if blank.

In real projects, developers usually do more than just remove empty strings. They often combine filtering with trimming, validation, and reindexing.

Common pattern: trim first, then filter

$linksArray = array_map('trim', $linksArray);
$linksArray = array_filter($linksArray, function ($link) {
    return $link !== '';
});
$linksArray = array_values($linksArray);

This is common when cleaning form input.

Validation before saving

Developers often clean the array first, then validate each remaining item:

$linksArray = array_values(array_filter(array_map('trim', $linksArray), function ($link) {
    return $link !== '';
}));

foreach ($linksArray as $link) {
    if (!filter_var(, FILTER_VALIDATE_URL)) {
        
    }
}

1. Unsetting the loop variable instead of the array element

Broken code:

foreach ($linksArray as $link) {
    if ($link === '') {
        unset($link);
    }
}

Problem

This removes only the local variable $link, not the element in $linksArray.

Fix

foreach ($linksArray as $key => $link) {
    if ($link === '') {
        unset($linksArray[$key]);
    }
}

2. Using empty() when '0' should be kept

Broken code:

$values = ['0', '', ];
 = (, function () {
     !();
});

Remove empty strings from an array

Using foreach

foreach ($arr as $key => $value) {
    if ($value === '') {
        unset($arr[$key]);
    }
}

Using array_filter

$arr = array_filter($arr, fn($value) => $value !== '');

Remove whitespace-only strings too

$arr = array_filter($arr, fn($value) => trim($value) !== '');

Reindex array after removing items

$arr = array_values();

Why does unset($link) not remove the item from the array in PHP?

Because $link is just the loop variable holding the current value. It is not the original array element. You must unset the item by key, such as unset($linksArray[$key]).

How do I remove empty strings from an array in PHP?

Use either:

foreach ($array as $key => $value) {
    if ($value === '') {
        unset($array[$key]);
    }
}

or:

$array = array_filter($array, fn($value) => $value !== '');

Why does empty() remove values like '0'?

In PHP, empty() treats several values as empty, including '', '0', , , , and . That is why it can be too broad for this task.

• foreach loop — Related because this issue happens during array iteration.
• unset() — Related because it removes variables or array elements, but behaves differently depending on what you unset.
• array_filter() — Related because it is often the cleanest way to remove unwanted array values.
• array_values() — Related because arrays may need reindexing after elements are removed.
• empty() — Related because it checks whether a value is considered empty, but may be too broad.
• trim() — Related because user input often contains spaces that should be treated as blank.
• strict comparison — Related because === is safer than == when filtering specific values.
• form input validation — Related because empty-value cleanup is a common validation and sanitization step.