Consider an array `foo` with multiple values, and consider the problem of deleting an element from the array, given just the value. Let the variable `$delValue` hold the value to be found and deleted.
Using `array_search` and `unset`
$key = array_search($delValue, $foo); if($key !== false) unset($foo[$key]);
The strict operator `!==` is required because the `array_search` function returns the key of the value in the array, if present. Since the key can be 0 and 0 evaluates to false in PHP, a strict comparison is required.
The method doesn’t work for multiple entries of the value, but with a slight modification, it can be made to :
while($key = array_search($delValue, $foo) !== false){
unset($foo[$key])
}
Using `array_diff`
This method only works for arrays whose members can be converted to strings.
$foo = array_diff($foo, [$delValue]);
`delValue` is cast into an array, and `array_diff` returns only the values of `foo` that will not be found in `[$delValue]`. Thus, all instances of `delValue` are deleted. This is a concise, powerful way that successfully deletes multiple entries of `delValue`.
Using `array_keys`
This is similar to the first method, but multiple entries can be successfully deleted.
foreach(array_keys($foo, $delValue, true) as $key){
unset($foo[$key]);
}
The argument `$delValue` tells the function `array_keys` to return keys only for the values *equal to* `delValue`, and the third argument `true` signifies that strict comparison (`===`) be used for checking the values.
Using Anonymous Functions with `array_filter`
A neat method that only works for versions of PHP >= 5.3.0.
$foo = array_filter($foo, function($value) use ($delValue) {
return ($value !== $delValue);
});
The anonymous function returns a boolean value, which determines whether an element should pass through the filter or not. All values of the array `foo` *strictly not equal to* `delValue` pass through and become a part of the new array. Worth noting that multiple instances of `delValue` are deleted.
Using `array_flip`
The function flips keys and values of the array passed as an argument. In the case of multiple values, only the latest key is used; the rest are discarded. Also, it’s necessary that the values be either integers or strings or be convertible as such.
$flippedFoo = array_flip($foo); unset($foo[$delValue]); $foo = array_flip($flippedFoo);
Multiple values are deleted as a side-effect of the `array_flip` call, although some data loss can possibly occur.
Using comparisons and loops
foreach($foo as $key => $value){
if($value == $delValue){ // === for strict comparison may be used
unset($foo[$key]);
}
}
Since each element is looped over, multiple values if present are all deleted.
Using `array_splice`
The function array_splice can also be used to delete values from an array.
$key = array_search($delValue, $foo); array_splice($foo, $key, 1);
The method only deletes one instance of the value from the array. In the case of associative arrays or arrays in which keys have gaps, the method fails.
