Remove one element in array php

How to delete a specific element from an array in PHP

In this article, you will learn how to delete an element from an array using PHP. We will cover different methods to do it on different types of arrays with multiple examples.

Before going further, let’s cover how the three functions that we will need later work.

The unset() function

The unset() function is an in-built function in PHP used to unset/destroy a given variable or a set of variables.

Syntax

Parameters

The function requires at least one variable as the parameter, but you can pass multiple variables that you want to unset, separated with commas.

The unset() function has no return value.

After a variable is unset, the program behaves as if the variable never existed and no longer recognizes it. If you unset a variable then try to use it again in your program, the system gives the undefined variable error.

If the unset() function is called inside a user-defined function, it unsets only the local variables. If you want to unset a global variable inside the function (one that is initialized outside it), then you have to use the $GLOBALS array to do so.

The array_splice() function

The array_splice() function is in-built in PHP and removes the selected elements from an array and replaces them with new elements.

Syntax

array_splice(array1, start, length, array2)

Parameters

The array_values() function

The array_values() is an in-built PHP function that re-indexes an array and returns it with numeric keys, starting at 0 and increasing by 1.

Syntax

The array is a required parameter that specifies the array to be worked on.

How to delete an element from an array in PHP

Method 1: Using the unset() function

The unset() function can be used to destroy a whole array in a variable, or a specified element in the array using its index or key.

Unlike for the ordinary variables where we just pass the variable name to the function, to delete a specific element from the array and leave its other elements intact, we have to include the element index or key to the array variable when passing it to the unset() function.

Example 1

Deleting an element from a numerically indexed array based on its index.

"; print_r ($fruits); echo "
"; unset($fruits[1]); echo "The array after deleting an element 
"; print_r ($fruits); 

The array before deleting an element
Array ( [0] => Apple
[1] => Mango
[2] => Avocado
[3] => Banana
[4] => Watermelon
[5] => Passion
)
The array after deleting an element
Array ( [0] => Apple
[2] => Avocado
[3] => Banana
[4] => Watermelon
[5] => Passion
)

The array indices start from 0. So array element with an index of 1 is actually the second element in the array. We have passed the array name with index 1 to the unset() function. From the output, you can see the second element (Mango) has been deleted from the array.

One thing you can note from the above example is that after deleting the element with index 1, the function keeps the other indices untouched, ie index one is missing with the resulting array starting with index 0 followed by 2. The unset() function doesn’t re-index the array after deleting an element from a numerically indexed array.

To fix that and have the resulting array re-indexed, all you need to do is pass the array to the array_values() function.

Example 2

Re-indexing a numeric array using array_values() function after deleting an element with the unset() function.

The array before deleting an element
Array ( [0] => Apple
[1] => HP
[2] => Dell
[3] => Lenovo
)

As you can see from the output, we have deleted «Toshiba» which occupied index 2 of the array. After passing the array to the array_values() function, it has been re-indexed to have «Dell» shift from index 3 to 2 and «Lenovo» from index 4 to 3.

Example 3

Deleting an element from an associative array based on its key.

 "John Doe", "email" => "johndoe@gmail.com", "age" => 28); echo "The array before deleting an element 
"; print_r ($person); echo "
"; unset($person["age"]); echo "The array after deleting an element 
"; print_r ($person); 

The array before deleting an element
Array ( [name] => John Doe
[email] => johndoe@gmail.com
[age] => 28
)
The array after deleting an element
Array ( [name] => John Doe
[email] => johndoe@gmail.com
)

As you can see the age element has been deleted from the array.

If you know an array element value and don’t know its key/index but you want to delete it, you can do so y first using the array_search() function to get its key, then use that key to delete it.

You pass two parameters to the array_search() function where the first is the value whose key you want to know, and the second is the actual array from which you are searching the value. The function returns the key/index of the array element with that value.

The key for Watermelon is: 4

Example

"; print_r ($laptops); echo "
"; unset($laptops[array_search("Dell", $laptops)]); echo "The array after deleting an element 
"; print_r ($laptops); 

The array before deleting an element
Array ( [0] => Apple
[1] => HP
[2] => Toshiba
[3] => Dell
[4] => Lenovo
)
The array after deleting an element
Array ( [0] => Apple
[1] => HP
[2] => Toshiba
[4] => Lenovo
)

From the example above, we have used the array_search() function with value «Dell» to find the index of the array element that matches it, then used that index to delete the element using the unset() function. You can from the output it has worked because «Dell» was deleted from the array.

Method 2: Using the array_splice() function

This function removes a specified range of array elements and re-indexes the array numerically automatically.

As opposed to the unset() function, the array_splice() needs the offset as the second parameter and not an array key of the element in the array variable.

Example 1

"; print_r ($companies); echo "
"; array_splice($companies, 3, 1); echo "The array after deleting an element 
"; print_r ($companies); 

The array before deleting an element
Array ( [0] => SpaceX
[1] => Apple
[2] => Google
[3] => Tesla
[4] => Microsoft
)
The array after deleting an element
Array ( [0] => SpaceX
[1] => Apple
[2] => Google
[3] => Microsoft
)

The offset (start) parameter starts counting values from 0, the same way as array indices. To delete «Tesla», which is the fourth element, we had to use offset 3 and 1 for the length parameter since we only wanted to delete one element.

If for instance, we wanted to delete both Tesla and Microsoft, we would have used array_splice($companies, 3, 2) instead. 3 specifying the deletion to start from the fourth element, and 2 specifying the number of elements to be deleted.

As opposed to the unset() function which leaves the array indices untouched, you can see from the example above the array_splice() has re-indexed the array elements after the deletion.

Example 2

Deleting an element from an associative array using the array_splice() function.

 "John Doe", "email" => "johndoe@gmail.com", "age" => 28); echo "The array before deleting an element 
"; print_r ($person); echo "
"; array_splice($person, 1, 1); echo "The array after deleting an element 
"; print_r ($person); 

The array before deleting an element
Array ( [name] => John Doe
[email] => johndoe@gmail.com
[age] => 28
)
The array after deleting an element
Array ( [name] => John Doe
[age] => 28
)

The second element (email), whose offset is 1 has been deleted from the example above.

Now you know how to delete specific elements from arrays in PHP.

Источник

array_pop

array_pop() pops and returns the value of the last element of array , shortening the array by one element.

Note: This function will reset() the array pointer of the input array after use.

Parameters

The array to get the value from.

Return Values

Returns the value of the last element of array . If array is empty, null will be returned.

Examples

Example #1 array_pop() example

$stack = array( «orange» , «banana» , «apple» , «raspberry» );
$fruit = array_pop ( $stack );
print_r ( $stack );
?>

After this, $stack will have only 3 elements:

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

and raspberry will be assigned to $fruit .

See Also

• array_push() — Push one or more elements onto the end of array
• array_shift() — Shift an element off the beginning of array
• array_unshift() — Prepend one or more elements to the beginning of an array

User Contributed Notes 11 notes

Notice:
the complexity of array_pop() is O(1).
the complexity of array_shift() is O(n).
array_shift() requires a re-index process on the array, so it has to run over all the elements and index them.

Note that array_pop doesn’t issue ANY warning or error if the array is already empty when you try to pop something from it. This is bizarre! And it will cause cascades of errors that are hard to resolve without knowing the real cause.

Rather than an error, it silently returns a NULL object, it appears, so in my case I ended up with warnings elsewhere about accessing elements of arrays with invalid indexes, as I was expecting to have popped an array. This behaviour (and the lack of any warning, when many trivial things are complained about verbosely) is NOT noted in the manual above. Popping an already empty stack should definitely trigger some sort of notice, to help debugging.

Sure, it’s probably good practice to wrap the pop in an if (count($array)) but that should be suggested in the manual, if there’s no error returned for trying something that should fail and obviously isn’t expected to return a meaningful result.

I wrote a simple function to perform an intersect on multiple (unlimited) arrays.

Pass an array containing all the arrays you want to compare, along with what key to match by.

function multipleArrayIntersect ( $arrayOfArrays , $matchKey )
<
$compareArray = array_pop ( $arrayOfArrays );

foreach( $compareArray AS $key => $valueArray ) <
foreach( $arrayOfArrays AS $subArray => $contents ) <
if (! in_array ( $compareArray [ $key ][ $matchKey ], $contents )) <
unset( $compareArray [ $key ]);
>
>
>

In a previous example .
function array_trim ( $array , $index ) if ( is_array ( $array ) ) unset ( $array [ $index ] );
array_unshift ( $array , array_shift ( $array ) );
return $array ;
>
else return false ;
>
>
?>

This have a problem. if u unset the last value and then use
array_unshift ( $array, array_shift ( $array ) );
?>

will return a : Array ( [0] => )
so u can fix it using.

if ( count ( $array ) > 0 ) array_unshift ( $values , array_shift ( $values ) );
?>

good luck 😉

alex.chacon@terra.com
Hi
Here there is a function that delete a elemente from a array and re calculate indexes

function eliminarElementoArreglo ( $array , $indice )
<
if ( array_key_exists ( $indice , $array ))
<
$temp = $array [ 0 ];
$array [ 0 ] = $array [ $indice ];
$array [ $indice ] = $temp ;
array_shift ( $array );

//reacomodamos ?ndices
for ( $i = 0 ; $i < $indice ; $i ++)
<
$dummy = $array [ $i ];
$array [ $i ] = $temp ;
$temp = $dummy ;
>
>
return $array ;
>
?>

I had a problem when using this function because my array was made up entirley of numbers, so I have made my own function. Hopefully it will be useful to somebody.

Источник