How to Delete an Element from an Array in PHP?

Removing a Single Element with unset()

The unset() function in PHP deletes an element from an array by its key. To remove a single element, pass the array and the key of the element you want to remove as arguments to the unset() function.

Here's an example that shows how to remove a single element from an array using unset():

$fruits = array("apple", "banana", "orange", "grape");
unset($fruits[2]);
print_r($fruits);

In this example, we have an array called $fruits with four elements. We use the unset() function to remove the third element (index 2) from the array, which is "orange". After removing the element, we use print_r() to display the updated array, which will output:

Array
(
    [0] => apple
    [1] => banana
    [3] => grape
)

When using unset() to remove an element, the array's indexes are not reindexed. After removing an element, the array may have gaps in its indexes.

Removing Multiple Elements with unset()

The unset() function also allows you to remove multiple elements from an array by specifying multiple keys. Pass multiple keys as separate arguments to the unset() function to delete multiple elements in a single statement.

Here's an example that demonstrates removing multiple elements from an array using unset():

$numbers = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
unset($numbers[3], $numbers[6], $numbers[8]);
print_r($numbers);

In this example, we have an array $numbers with ten elements. We use the unset() function to remove the fourth element (index 3), the seventh element (index 6), and the ninth element (index 8) from the array. After removing the elements, the updated array will be:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [4] => 5
    [5] => 6
    [7] => 8
    [9] => 10
)

The unset() function removes the specified elements from the array, leaving the remaining elements intact. The array's indexes are not reindexed automatically.

Deleting Elements with array_splice()

The array_splice() function in PHP lets you remove elements from an array by specifying the starting index and the number of elements to remove. This function changes the original array and returns the removed elements as a new array.

Here's an example that shows how to use array_splice() to remove elements from an array:

$fruits = array("apple", "banana", "orange", "grape", "kiwi");
$removed_fruits = array_splice($fruits, 2, 2);
print_r($fruits);
print_r($removed_fruits);

In this example, we have an array $fruits with five elements. We use array_splice() to remove two elements starting from index 2 (the third element). The first parameter specifies the array, the second parameter is the starting index, and the third parameter is the number of elements to remove.

After using array_splice(), the $fruits array will contain the remaining elements:

Array
(
    [0] => apple
    [1] => banana
    [2] => kiwi
)

The removed elements are returned as a new array, which is stored in the $removed_fruits variable:

Array
(
    [0] => orange
    [1] => grape
)

Reindexing the Array After Using array_splice()

It's important to note that array_splice() automatically reindexes the array after removing elements. The remaining elements are shifted to fill the gaps created by the removed elements, and the array's indexes are updated.

Here's an example that shows the reindexing behavior of array_splice():

$numbers = array(5, 10, 15, 20, 25);
array_splice($numbers, 1, 3);
print_r($numbers);

In this example, we remove three elements starting from index 1 (the second element) from the $numbers array using array_splice(). After removing the elements, the array is reindexed:

Array
(
    [0] => 5
    [1] => 25
)

The remaining elements are shifted to fill the gaps, and the array's indexes are updated.

Deleting Elements from an Associative Array with unset()

In PHP, you can remove elements from an associative array using the unset() function by specifying the key of the element you want to delete. The unset() function removes the key-value pair from the array.

Here's an example that shows how to remove an element from an associative array using unset():

$person = array(
    "name" => "John",
    "age" => 30,
    "city" => "New York",
    "country" => "USA"
);

unset($person["city"]);

print_r($person);

In this example, we have an associative array called $person that represents a person's information. Each key-value pair in the array matches a specific attribute of the person.

To remove the "city" element from the $person array, we use the unset() function and pass the array variable followed by the key in square brackets: unset($person["city"]). This removes the key-value pair where the key is "city".

After removing the element, the print_r() function is used to show the updated $person array:

Array
(
    [name] => John
    [age] => 30
    [country] => USA
)

As you can see, the "city" element has been removed from the array, and the remaining key-value pairs are kept.

It's important to note that when you remove an element from an associative array using unset(), the array's structure stays the same. The keys of the remaining elements are not changed, and no reindexing happens.

You can remove multiple elements from an associative array by specifying multiple keys in separate unset() statements:

unset($person["age"], $person["country"]);

This statement removes both the "age" and "country" elements from the $person array.

Using unset() is an easy way to remove elements from an associative array when you know the specific keys you want to delete.

$shoppingCart = array(
    "item1" => 2,
    "item2" => 1,
    "item3" => 3
);

unset($shoppingCart["item2"]);

print_r($shoppingCart);

Array
(
    [item1] => 2
    [item3] => 3
)

$userDatabase = array(
    "user1" => array("name" => "John", "email" => "john@example.com"),
    "user2" => array("name" => "Jane", "email" => "jane@example.com"),
    "user3" => array("name" => "Bob", "email" => "bob@example.com")
);

unset($userDatabase["user2"]);

print_r($userDatabase);

Array
(
    [user1] => Array
        (
            [name] => John
            [email] => john@example.com
        )

    [user3] => Array
        (
            [name] => Bob
            [email] => bob@example.com
        )
)

Creating a New Array without Specific Elements

PHP's array_diff() function creates a new array that contains all the elements from the first array that are not present in any of the other arrays passed as parameters. This function can remove elements from an array by creating a new array without the specified elements.

Here's an example that shows how to use array_diff() to remove elements from an array:

$original_array = array("apple", "banana", "orange", "grape", "kiwi");
$elements_to_remove = array("banana", "grape");
$new_array = array_diff($original_array, $elements_to_remove);
print_r($new_array);

In this example, we have an array called $original_array that contains five elements. We also have another array $elements_to_remove that specifies the elements we want to remove from $original_array.

We use the array_diff() function to create a new array $new_array that contains all the elements from $original_array that are not present in $elements_to_remove. The first parameter of array_diff() is the original array, and the second parameter is the array of elements to remove.

After running this code, the $new_array will contain the following elements:

Array
(
    [0] => apple
    [2] => orange
    [4] => kiwi
)

The array_diff() function removed the "banana" and "grape" elements from $original_array and returned a new array with the remaining elements.

It's important to note that array_diff() compares the values of the arrays, not the keys. The resulting array will have new numeric keys starting from zero, even if the original array had string or non-sequential keys.

You can also use array_diff() with multiple arrays to remove elements present in any of the other arrays:

$array1 = array("a" => "apple", "b" => "banana", "c" => "cherry");
$array2 = array("a" => "apple", "b" => "blueberry", "d" => "date");
$array3 = array("a" => "apricot", "b" => "banana", "e" => "elderberry");
$result = array_diff($array1, $array2, $array3);
print_r($result);

In this example, array_diff() compares $array1 with $array2 and $array3 and returns a new array containing the elements from $array1 that are not present in either $array2 or $array3:

Array
(
    [c] => cherry
)

The array_diff() function can be very useful when you need to filter an array based on specific values without changing the original array. It gives you the flexibility to generate a new array with only the desired elements.

$email_list = array("john@example.com", "jane@example.com", "bob@example.com", "alice@example.com");
$blocked_emails = array("jane@example.com", "bob@example.com");
$filtered_emails = array_diff($email_list, $blocked_emails);
print_r($filtered_emails);

Array
(
    [0] => john@example.com
    [3] => alice@example.com
)

$array1 = array("apple", "banana", "orange", "grape");
$array2 = array("banana", "kiwi", "pear");
$diff = array_diff($array1, $array2);
print_r($diff);

Array
(
    [0] => apple
    [2] => orange
    [3] => grape
)

Removing the Last Element with array_pop()

The array_pop() function in PHP removes the last element from an array and returns the value of the removed element. This function changes the original array by removing the last element and shortening the array by one element.

Here's an example that shows how to remove the last element from an array using array_pop():

$fruits = array("apple", "banana", "orange", "grape");
$removed_fruit = array_pop($fruits);
echo "Removed fruit: " . $removed_fruit . "\n";
print_r($fruits);

In this example, we have an array $fruits with four elements. We use the array_pop() function to remove the last element from the array. The removed element is stored in the $removed_fruit variable.

After running this code, the output will be:

Removed fruit: grape
Array
(
    [0] => apple
    [1] => banana
    [2] => orange
)

The array_pop() function removed the last element "grape" from the $fruits array and returned its value. The $fruits array is then printed using print_r(), showing that it now contains only three elements.

It's important to note that array_pop() returns the value of the removed element, which you can store in a variable or use directly. If the array is empty, array_pop() returns null.

$recentActions = array();
$maxActions = 5;

function addRecentAction($action) {
    global $recentActions, $maxActions;

    if (count($recentActions) >= $maxActions) {
        array_pop($recentActions);
    }

    array_unshift($recentActions, $action);
}

addRecentAction("Logged in");
addRecentAction("Viewed profile");
addRecentAction("Updated settings");
addRecentAction("Submitted form");
addRecentAction("Logged out");
addRecentAction("Logged in");

print_r($recentActions);

Array
(
    [0] => Logged in
    [1] => Logged out
    [2] => Submitted form
    [3] => Updated settings
    [4] => Viewed profile
)

Removing the First Element with array_shift()

Similar to array_pop(), the array_shift() function removes the first element from an array and returns the value of the removed element. This function also changes the original array by removing the first element and shifting all the remaining elements to fill the gap.

Here's an example that demonstrates removing the first element from an array using array_shift():

$numbers = array(10, 20, 30, 40, 50);
$removed_number = array_shift($numbers);
echo "Removed number: " . $removed_number . "\n";
print_r($numbers);

In this example, we have an array $numbers with five elements. We use the array_shift() function to remove the first element from the array. The removed element is stored in the $removed_number variable.

After running this code, the output will be:

Removed number: 10
Array
(
    [0] => 20
    [1] => 30
    [2] => 40
    [3] => 50
)

The array_shift() function removed the first element "10" from the $numbers array and returned its value. The $numbers array is then printed using print_r(), showing that it now contains the remaining four elements, with their indexes shifted accordingly.

Like array_pop(), array_shift() returns the value of the removed element. If the array is empty, array_shift() returns null.

$taskQueue = array("Task 1", "Task 2", "Task 3", "Task 4");

while (!empty($taskQueue)) {
    $currentTask = array_shift($taskQueue);
    echo "Processing task: " . $currentTask . "\n";
    // Perform task processing here
}

Processing task: Task 1
Processing task: Task 2
Processing task: Task 3
Processing task: Task 4