Php deleting element from array

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.

Источник

Php deleting element from array

// Before php 5.4
$array = array(1,2,3);

// since php 5.4 , short syntax
$array = [1,2,3];

// I recommend using the short syntax if you have php version >= 5.4

Used to creating arrays like this in Perl?

Looks like we need the range() function in PHP:

$array = array_merge (array( ‘All’ ), range ( ‘A’ , ‘Z’ ));
?>

You don’t need to array_merge if it’s just one range:

There is another kind of array (php>= 5.3.0) produced by

$array = new SplFixedArray(5);

Standard arrays, as documented here, are marvellously flexible and, due to the underlying hashtable, extremely fast for certain kinds of lookup operation.

Supposing a large string-keyed array

$arr=[‘string1’=>$data1, ‘string2’=>$data2 etc. ]

when getting the keyed data with

php does *not* have to search through the array comparing each key string to the given key (‘string1’) one by one, which could take a long time with a large array. Instead the hashtable means that php takes the given key string and computes from it the memory location of the keyed data, and then instantly retrieves the data. Marvellous! And so quick. And no need to know anything about hashtables as it’s all hidden away.

However, there is a lot of overhead in that. It uses lots of memory, as hashtables tend to (also nearly doubling on a 64bit server), and should be significantly slower for integer keyed arrays than old-fashioned (non-hashtable) integer-keyed arrays. For that see more on SplFixedArray :

Unlike a standard php (hashtabled) array, if you lookup by integer then the integer itself denotes the memory location of the data, no hashtable computation on the integer key needed. This is much quicker. It’s also quicker to build the array compared to the complex operations needed for hashtables. And it uses a lot less memory as there is no hashtable data structure. This is really an optimisation decision, but in some cases of large integer keyed arrays it may significantly reduce server memory and increase performance (including the avoiding of expensive memory deallocation of hashtable arrays at the exiting of the script).

When creating arrays , if we have an element with the same value as another element from the same array, we would expect PHP instead of creating new zval container to increase the refcount and point the duplicate symbol to the same zval. This is true except for value type integer.
Example:

$arr = [‘bebe’ => ‘Bob’, ‘age’ => 23, ‘too’ => 23 ];
xdebug_debug_zval( ‘arr’ );

(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=0, is_ref=0)int 23
‘too’ => (refcount=0, is_ref=0)int 23

but :
$arr = [‘bebe’ => ‘Bob’, ‘age’ => 23, ‘too’ => ’23’ ];
xdebug_debug_zval( ‘arr’ );

(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=0, is_ref=0)int 23
‘too’ => (refcount=1, is_ref=0)string ’23’ (length=2)
or :

$arr = [‘bebe’ => ‘Bob’, ‘age’ => [1,2], ‘too’ => [1,2] ];
xdebug_debug_zval( ‘arr’ );

(refcount=2, is_ref=0)
array (size=3)
‘bebe’ => (refcount=1, is_ref=0)string ‘Bob’ (length=3)
‘age’ => (refcount=2, is_ref=0)
array (size=2)
0 => (refcount=0, is_ref=0)int 1
1 => (refcount=0, is_ref=0)int 2
‘too’ => (refcount=2, is_ref=0)
array (size=2)
0 => (refcount=0, is_ref=0)int 1
1 => (refcount=0, is_ref=0)int 2

This function makes (assoc.) array creation much easier:

function arr (. $array )< return $array ; >
?>

It allows for short syntax like:

$arr = arr ( x : 1 , y : 2 , z : 3 );
?>

Instead of:

$arr = [ «x» => 1 , «y» => 2 , «z» => 3 ];
// or
$arr2 = array( «x» => 1 , «y» => 2 , «z» => 3 );
?>

Sadly PHP 8.2 doesn’t support this named arguments in the «array» function/language construct.

Источник