I have a PHP array as follows:
$messages = [312, 401, 1599, 3, ...];
I want to delete the element containing the value $del_val (for example, $del_val=401), but I don't know its key. This might help: each value can only be there once.
I'm looking for the simplest function to perform this task please.
转载于:https://stackoverflow.com/questions/7225070/php-array-delete-by-value-not-key
Using array_search() and unset, try the following:
if (($key = array_search($del_val, $messages)) !== false) {
unset($messages[$key]);
}
array_search() returns the key of the element it finds, which can be used to remove that element from the original array using unset(). It will return FALSE on failure, however it can return a false-y value on success (your key may be 0 for example), which is why the strict comparison !== operator is used.
The if() statement will check whether array_search() returned a value, and will only perform an action if it did.
Get the key with array_search().
If you know for definite that your array will contain only one element with that value, you can do
$key = array_search($del_val, $array);
if (false !== $key) {
unset($array[$key]);
}
If, however, your value might occur more than once in your array, you could do this
$array = array_filter($array, function($e) use ($del_val) {
return ($e !== $del_val);
});
Note: The second option only works for PHP5.3+ with Closures
function array_remove_by_value($array, $value)
{
return array_values(array_diff($array, array($value)));
}
$array = array(312, 401, 1599, 3);
$newarray = array_remove_by_value($array, 401);
print_r($newarray);
Output
Array ( [0] => 312 [1] => 1599 [2] => 3 )
Well, deleting an element from array is basically just set difference with one element.
array_diff( [312, 401, 15, 401, 3], [401] ) // removing 401 returns [312, 15, 3]
It generalizes nicely, you can remove as many elements as you like at the same time, if you want.
Disclaimer: Note that my solution produces a new copy of the array while keeping the old one intact in contrast to the accepted answer which mutates. It might be a bit slower because of this.
$fields = array_flip($fields);
unset($fields['myvalue']);
$fields = array_flip($fields);
One interesting way is by using array_keys():
foreach (array_keys($messages, 401, true) as $key) {
unset($messages[$key]);
}
The array_keys() function takes two additional parameters to return only keys for a particular value and whether strict checking is required (i.e. using === for comparison).
This can also remove multiple array items with the same value (e.g. [1, 2, 3, 3, 4]).
Have a look at following code:
$arr = array('nice_item', 'remove_me', 'another_liked_item', 'remove_me_also');
You can do:
$arr = array_diff($arr, array('remove_me', 'remove_me_also'));
And that will get you this array:
array('nice_item', 'another_liked_item')
To delete multiple values try this one
while (($key = array_search($del_val, $messages)) !== false)
{
unset($messages[$key]);
}
Or simply, manual way:
foreach ($array as $key => $value){
if ($value == $target_value) {
unset($array[$key]);
}
}
This is the safest of them because you have full control on your array
Or a one-liner using the or operator:
($key = array_search($del_val, $messages)) !== false or unset($messages[$key]);
Another idea to delete a value of an array, use array_diff. If I want to
$my_array = array(1=>"a", "second_value"=>"b", 3=>"c", "d");
$new_array_without_value_c = array_diff($my_array, array("c"));
If you don't know its key it means it doesn't matter.
You could place the value as the key, it means it will instant find the value. Better than using searching in all elements over and over again.
$messages=array();
$messages[312] = 312;
$messages[401] = 401;
$messages[1599] = 1599;
$messages[3] = 3;
unset($messages[3]); // no search needed
If your values you want to delete are, or can, be in an array. Use the array_diff function. Seems to work great for things like this.
$arrayWithValuesRemoved = array_diff($arrayOfData, $arrayOfValuesToRemove);
By the following code, the repetitive values will be removed from the $messages.
$messages = array_diff($messages, array(401));
@Bojangles answer did help me. Thank you.
In my case, the array could be associative or not, so I added this function
function test($value, $tab) {
if(($key = array_search($value, $tab)) !== false) {
unset($tab[$key]); return true;
} else if (array_key_exists($value, $tab)){
unset($tab[$value]); return true;
} else {
return false; // the $value is not in the array $tab
}
}
Regards
The Best way is array_splice
array_splice($array, array_search(58, $array ), 1);
Reason for Best is here at http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/
If you have > php5.3, there is the one line code :
$array = array_filter($array, function($i) use ($value){return $i != $value;});
OK.. I know this is not efficient at all but is simple, intuitive and easy to read.
So if someone is looking for a not so fancy solution which can be extended to work with more values, or more specific conditions .. here is a simple code:
$result = array();
$del_value = 401;
//$del_values = array(... all the values you don`t wont);
foreach($arr as $key =>$value){
if ($value !== $del_value){
$result[$key] = $value;
}
//if(!in_array($value, $del_values)){
// $result[$key] = $value;
//}
//if($this->validete($value)){
// $result[$key] = $value;
//}
}
return $result
you can do:
unset($messages[array_flip($messages)['401']]);
Explanation: Delete the element that has the key 401 after flipping the array.
you can refer this URL : for function
array-diff-key()
<?php
$array1 = array('blue' => 1, 'red' => 2, 'green' => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan' => 8);
var_dump(array_diff_key($array1, $array2));
?>
Then output should be,
array(2) {
["red"]=>
int(2)
["purple"]=>
int(4)
}
Borrowed the logic of underscoreJS _.reject and created two functions (people prefer functions!!)
array_reject_value: This function is simply rejecting the value specified (also works for PHP4,5,7)
function array_reject_value(array &$arrayToFilter, $deleteValue) {
$filteredArray = array();
foreach ($arrayToFilter as $key => $value) {
if ($value !== $deleteValue) {
$filteredArray[] = $value;
}
}
return $filteredArray;
}
array_reject: This function is simply rejecting the callable method (works for PHP >=5.3)
function array_reject(array &$arrayToFilter, callable $rejectCallback) {
$filteredArray = array();
foreach ($arrayToFilter as $key => $value) {
if (!$rejectCallback($value, $key)) {
$filteredArray[] = $value;
}
}
return $filteredArray;
}
So in our current example we can use the above functions as follows:
$messages = [312, 401, 1599, 3, 6];
$messages = array_reject_value($messages, 401);
or even better: (as this give us a better syntax to use like the array_filter one)
$messages = [312, 401, 1599, 3, 6];
$messages = array_reject($messages, function ($value) {
return $value === 401;
});
The above can be used for more complicated stuff like let's say we would like to remove all the values that are greater or equal to 401 we could simply do this:
$messages = [312, 401, 1599, 3, 6];
$greaterOrEqualThan = 401;
$messages = array_reject($messages, function ($value) use $greaterOrEqualThan {
return $value >= $greaterOrEqualThan;
});
As per your requirement "each value can only be there once" if you are just interested in keeping unique values in your array, then the array_unique() might be what you are looking for.
Input:
$input = array(4, "4", "3", 4, 3, "3");
$result = array_unique($input);
var_dump($result);
Result:
array(2) {
[0] => int(4)
[2] => string(1) "3"
}
The accepted answer, converts the array to associative array, so, if you would like to keep it as non associative array with the accepted answer, you may have to use array_values too.
if(($key = array_search($del_val, $messages)) !== false) {
unset($messages[$key]);
$arr = array_values($messages);
}
The reference is here
single liner code (thanks to array_diff() ), use following:
$messages = array_diff($messages, array(401));