PHP'de bir diziden yinelenen değerler nasıl kaldırılır

PHP'deki bir diziden yinelenen değerleri nasıl kaldırabilirim?

Array_unique () kullanın .

Misal:

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

kullanım array_values(array_unique($array));

array_unique: benzersiz dizi için array_values: yeniden endeksleme için

//Find duplicates 

$arr = array( 
    'unique', 
    'duplicate', 
    'distinct', 
    'justone', 
    'three3', 
    'duplicate', 
    'three3', 
    'three3', 
    'onlyone' 
);

$unique = array_unique($arr); 
$dupes = array_diff_key( $arr, $unique ); 
    // array( 5=>'duplicate', 6=>'three3' 7=>'three3' )

// count duplicates

array_count_values($dupes); // array( 'duplicate'=>1, 'three3'=>2 )

Benim için çalışan tek şey:

$array = array_unique($array, SORT_REGULAR);

Düzenle: SORT_REGULARorijinal dizinin aynı sırasını korur.

$result = array();
foreach ($array as $key => $value){
  if(!in_array($value, $result))
    $result[$key]=$value;
}

benzersiz ve çoğaltılmış öğeler almakarray_unique() istiyorsanız bazen yol değildir ...

$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

sonuçları

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

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

Bu son değeri kullanmak için böyle bir dizi oluşturabiliriz, sütun veya anahtar değerine güncellenir ve diziden benzersiz bir değer alırız ...

$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);

explode(",", implode(",", array_unique(explode(",", $YOUR_ARRAY))));

Bu, anahtar ilişkilendirmelerle ilgilenecek ve ortaya çıkan yeni dizi için anahtarları serileştirecektir :-)

Dizinizin boyutuna bağlı olarak, buldum

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

array_unique'den daha hızlı olabilir.

Bunu yapmanın harika bir yolu. Çıktının tekrar bir dizi olduğundan emin olmak isteyebilirsiniz. Şimdi sadece son benzersiz değeri gösteriyorsunuz.

Bunu dene:

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

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

    if (@!in_array($classified->category,$arr)){        
                                    $arr[] = $classified->category;
                                 ?>

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

dizide ilk kez kontrol değeri ve aynı değer bulundu onu yoksay

PHP'de ilişkilendirilebilir bir diziden yinelenen değerleri kaldırın.

$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]);
}

Dizi ([0] => aaa-aaa [1] => 12/1/1 [2] => 1,15)

Bunları yapmanın birkaç yolu olabilir, bunlar aşağıdaki gibidir

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

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

Performansla ilgileniyorsanız ve basit bir diziye sahipseniz, şunları kullanın:

array_keys(array_flip($array));

Array_unique'den çok daha hızlı.

$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);

$arrDuplicate = array ("","",1,3,"",5);
 foreach(array_unique($arrDuplicate) as $v){
  if($v != "" ){$arrRemoved = $v;  }}
print_r($arrRemoved);

function arrayUnique($myArray)
{
    $newArray = Array();
    if (is_array($myArray))
    {
        foreach($myArray as $key=>$val)
        {
            if (is_array($val))
            {
                $val2 = arrayUnique($val);
            }
            else
            {
                $val2 = $val;
                $newArray=array_unique($myArray);
                $newArray=deleteEmpty($newArray);
                break;
            }
            if (!empty($val2))
            {
                $newArray[$key] = $val2;
            }
        }
    }
    return ($newArray);
}

function deleteEmpty($myArray)
{
    $retArray= Array();
    foreach($myArray as $key=>$val)
    {
        if (($key<>"") && ($val<>""))
        {
            $retArray[$key] = $val;
        }
    }
    return $retArray;
}

bu kısa ve tatlı kodu deneyin -

$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);

Çıktı -

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

<?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;
}

Burada ikinci bir boş dizi oluşturdum ve foryinelenen ilk dizi ile döngü kullandım . İlk dizinin sayısı kadar çalışır. Daha sonra, dizinin ilk diziyle konumuyla karşılaştırılır ve bu öğenin zaten kullanılarak veya kullanılmadığıyla eşleştirilir in_array. Değilse, bu öğeyi ile ikinci diziye ekler array_push.

$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);

Bu fonksiyon ile yapılabilir Ben üç fonksiyon yinelenen dizi yinelenen değerleri döndürür yaptı.

İkinci işlev tek dönüş yalnızca dizide yinelenmeyen tek ortalama değerler ve üçüncü ve tam işlev tüm değerleri döndürür, ancak herhangi bir değer çoğaltılırsa çoğaltılmaz; tek tek dönüştürür;

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("a" => "moon", "star", "b" => "moon", "star", "sky");

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

ref: Demo

Array_unique () işlevi için bir alternatif ..

Brute force algoritmasını kullanma

// [1] Bu, yinelenen öğeler içeren dizimiz

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

// [2] Çoğaltılan öğe içermeyen yeni dizi için kapsayıcı

$ arr = [];

// [3] çoğaltılan dizinin uzunluğunu al ve döngü için kullanılacak değişkene ayarla

$ len = sayım ($ eşleşmeleri);

// [4] Dizi anahtarıyla ($ i) eşleşirse, geçerli döngü Yineleme kullanılamaz
// [4] $ arr dizisi, eşleşmelerin geçerli yineleme anahtar değerini [$ i]
// [4] dizi dizisine.

$ İ ($ i = 0

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
)

Bunu herhangi bir işlev kullanmadan yaptım.

$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>";
}