如何在PHP中从数组中删除重复值

如何在PHP中从数组中删除重复值？

使用

例如：

$array = array(1, 2, 2, 3);
$array = array_unique($array); // Array is now (1, 2, 3)

---

我这样做没有使用任何函数

$arr = array("1", "2", "3", "4", "5", "4", "2", "1");

$len = count($arr);
for ($i = 0; $i < $len; $i++) {
  $temp = $arr[$i];
  $j = $i;
  for ($k = 0; $k < $len; $k++) {
    if ($k != $j) {
      if ($temp == $arr[$k]) {
        echo $temp."<br>";
        $arr[$k]=" ";
      }
    }
  }
}

for ($i = 0; $i < $len; $i++) {
  echo $arr[$i] . " <br><br>";
}

$arr=数组（“1”、“2”、“3”、“4”、“5”、“4”、“2”、“1”）；
$len=计数（$arr）；
对于（$i=0；$i<$len；$i++）{
$temp=$arr[$i]；
$j=$i；
对于（$k=0；$k<$len；$k++）{
如果（$k！=$j）{
如果（$temp==$arr[$k]）{
echo$temp.“
”；
$arr[$k]=“”；
}
}
}
}
对于（$i=0；$i<$len；$i++）{
回声$arr[$i]。“

”；
}

分解（“，”，内爆（“，”，数组唯一（分解（“，”，$YOUR\u数组）））

这将处理键关联并序列化生成的新数组的键：-）
有时
array\u unique（）
不是这样，
如果您想获取唯一和重复的项目

$unique=array("","A1","","A2","","A1","");
$duplicated=array();

foreach($unique as $k=>$v) {

if( ($kt=array_search($v,$unique))!==false and $k!=$kt )
 { unset($unique[$kt]);  $duplicated[]=$v; }

}

sort($unique); // optional
sort($duplicated); // optional

结果

array ( 0 => '', 1 => 'A1', 2 => 'A2', ) /* $unique */

array ( 0 => '', 1 => '', 2 => '', 3 => 'A1', ) /* $duplicated */

这是一个很好的方法。可能需要确保其输出再次返回数组。现在只显示最后一个唯一值

试试这个：

$arrDuplicate = array ("","",1,3,"",5);

foreach (array_unique($arrDuplicate) as $v){
  if($v != "") { $arrRemoved[] = $v; }
}
print_r ($arrRemoved);

函数arrayUnique（$myArray）
{
$newArray=Array（）；
if（is_数组（$myArray））
{
foreach（$myArray作为$key=>$val）
{
if（is_数组（$val））
{
$val2=arrayUnique（$val）；
}
其他的
{
$val2=$val；
$newArray=array\u unique（$myArray）；
$newArray=deletempty（$newArray）；
打破
}
如果（！空（$val2））
{
$newArray[$key]=$val2；
}
}
}
返回（$newArray）；
}
函数deletempty（$myArray）
{
$retArray=Array（）；
foreach（$myArray作为$key=>$val）
{
如果（$key“”）&&（$val“”）
{
$retArray[$key]=$val；
}
}
返回$retArray；
}
试试这个简短而甜蜜的代码-

$array = array (1,4,2,1,7,4,9,7,5,9);
$unique = array();

foreach($array as $v){
  isset($k[$v]) || ($k[$v]=1) && $unique[] = $v;
  }

var_dump($unique);

输出-

array(6) {
  [0]=>
  int(1)
  [1]=>
  int(4)
  [2]=>
  int(2)
  [3]=>
  int(7)
  [4]=>
  int(9)
  [5]=>
  int(5)
}

它可以通过函数I来完成，函数I有三个重复，返回数组中重复的值

第二个函数single只返回那些在数组中不重复的值，第三个函数和完整函数返回所有值但不重复，如果任何值重复，则将其转换为single

function duplicate($arr) {
    $duplicate;
    $count = array_count_values($arr);
    foreach($arr as $key => $value) {
        if ($count[$value] > 1) {
            $duplicate[$value] = $value;
        }
    }
    return $duplicate;
}
function single($arr) {
    $single;
    $count = array_count_values($arr);
    foreach($arr as $key => $value) {
        if ($count[$value] == 1) {
            $single[$value] = $value;
        }
    }
    return $single;
}
function full($arr, $arry) {
    $full = $arr + $arry;
    sort($full);
    return $full;
}

根据阵列的大小，我发现

$array = array_values( array_flip( array_flip( $array ) ) );

可以比阵列速度快
 唯一对我有用的是：

$array = array_unique($array, SORT_REGULAR);

编辑：
SORT\u REGULAR
保持原始数组的相同顺序。
使用
array\u值（array\u unique（$array））

<?php
$arr1 = [1,1,2,3,4,5,6,3,1,3,5,3,20];    
print_r(arr_unique($arr1));


function arr_unique($arr) {
  sort($arr);
  $curr = $arr[0];
  $uni_arr[] = $arr[0];
  for($i=0; $i<count($arr);$i++){
      if($curr != $arr[$i]) {
        $uni_arr[] = $arr[$i];
        $curr = $arr[$i];
      }
  }
  return $uni_arr;
}

array\u unique
：用于唯一数组
array\u值
：如果（@！in\u array（$classified->category，$arr））{
    if (@!in_array($classified->category,$arr)){        
                                    $arr[] = $classified->category;
                                 ?>

            <?php } endwhile; wp_reset_query(); ?>

$arr[]=$classified->category；
?>

第一次检查数组中的值并发现相同的值忽略它
我们可以创建这样的数组类型，使用最后一个值将更新为列或键值，我们将从数组中获得唯一值

$array = array (1,3,4,2,1,7,4,9,7,5,9);
    $data=array();
    foreach($array as $value ){

        $data[$value]= $value;

    }

    array_keys($data);
    OR
    array_values($data);

在PHP中删除关联数组中的重复值

$arrDup = Array ('0' => 'aaa-aaa' , 'SKU' => 'aaa-aaa' , '1' => '12/1/1' , 'date' => '12/1/1' , '2' => '1.15' , 'cost' => '1.15' );

foreach($arrDup as $k =>  $v){
  if(!( isset ($hold[$v])))
      $hold[$v]=1;
  else
      unset($arrDup[$k]);
}

数组（[0]=>aaaaaaa[1]=>12/1/1[2]=>1.15）
可以有多种方法来执行这些操作，如下所示

//first method
$filter = array_map("unserialize", array_unique(array_map("serialize", $arr)));

//second method
$array = array_unique($arr, SORT_REGULAR);

如果您关心性能并使用简单阵列，请使用：

array_keys(array_flip($array));

它比array\u unique快很多倍。
这里我创建了第二个空数组，并使用
for
循环第一个有重复项的数组。它将运行与第一个数组的计数相同的时间。然后将数组的位置与第一个数组进行比较，并通过usi匹配它是否已经有此项ng
在数组中
。如果没有，它将使用
数组推送
将该项添加到第二个数组中

$a = array(1,2,3,1,3,4,5);
$count = count($a);
$b = [];
for($i=0; $i<$count; $i++){
    if(!in_array($a[$i], $b)){
        array_push($b, $a[$i]);
    }
}
print_r ($b);

$a=数组（1,2,3,1,3,4,5）；
$count=计数（$a）；
$b=[]；
对于（$i=0；$i）
ref:
数组的另一种方法\u unique（）函数

使用蛮力算法


/`output->Array（[0]=>302[1]=>276[2]=>301）`
array\u unique函数只是PHP中处理数组的真正有用的本机函数之一。我最近写了一篇关于数组的文章，以及修改和操作PHP数组的spread操作符：

当
$YOUR_数组
是
数组（“1”、“2”、“3”）
？@kiamlaluno-：）时，
爆炸（“，”$YOUR_数组）
会有什么影响，答案是：警告：爆炸（）期望参数2是字符串，数组在…行中给出…@JesseChisholm是的，这就是重点，但显然没有人注意到代码。@Ian-
注意数组_unique（）不适用于多维数组。
上述操作将保留元素的键。如果要重新索引元素，请另外应用数组值：这对我不起作用，请使用：
$array=array\u unique（$array，SORT\u REGULAR）
@PeterAjtai:谢谢你在评论部分突出显示。这为我节省了很多时间。这真的不能解释任何事情，而且似乎也不“聪明”。你可以通过编辑自己的帖子来解释原因，只需点击“编辑”链接到你答案的末尾。我还建议你看看常见问题解答：像这样滥用布尔运算符来控制流是不必要的混乱。只需使用
if
。关于这里发生的事情的更多信息，以及使用更大或更小的数组是否更快。双翻转将删除重复的值，因为key不能存在两次，否则会被覆盖。如果任何值被复制并且数组被翻转，最后一次出现的值（我假设）将是键的值。在PHP 7中，我注意到多次翻转多维数组可能会意外地重新排列数组元素。放置计数（$arr）循环中的速度非常慢+1
array\u unique
返回一个包含键和值对的对象，并且
array\u值
仅返回作为数组的值。您可以分享一些关于该代码的解释吗？例如，
$result = array();
foreach ($array as $key => $value){
  if(!in_array($value, $result))
    $result[$key]=$value;
}

//first method
$filter = array_map("unserialize", array_unique(array_map("serialize", $arr)));

//second method
$array = array_unique($arr, SORT_REGULAR);

array_keys(array_flip($array));

$a = array(1,2,3,1,3,4,5);
$count = count($a);
$b = [];
for($i=0; $i<$count; $i++){
    if(!in_array($a[$i], $b)){
        array_push($b, $a[$i]);
    }
}
print_r ($b);

$a = array(1, 2, 3, 4); 
$b = array(1, 6, 5, 2, 9); 
$c = array_merge($a, $b);
$unique = array_keys(array_flip($c));
print_r($unique);

$array = array("a" => "moon", "star", "b" => "moon", "star", "sky");

// Deleting the duplicate items
$result = array_unique($array);
print_r($result);



//[1] This our array with duplicated items


$matches = ["jorge","melvin","chelsy","melvin","jorge","smith"];


//[2] Container for the new array without any duplicated items


$arr = [];


//[3] get the length of the duplicated array and set it to the var len to be use for for loop


$len = count($matches);


//[4] If matches array key($i) current loop Iteration is not available in
//[4] the array $arr then push the current iteration key value of the matches[$i]
//[4] to the array arr.


for($i=0;$i

if(array_search($matches[$i], $arr) === false){

    array_push($arr,$matches[$i]);
}
}

//print the array $arr.
print_r($arr);

//Result: Array
(
[0] => jorge
[1] => melvin
[2] => chelsy
[3] => smith
)

<?php
$a=array("1"=>"302","2"=>"302","3"=>"276","4"=>"301","5"=>"302");
print_r(array_values(array_unique($a)));
?>//`output -> Array ( [0] => 302 [1] => 276 [2] => 301 )`