Comment supprimer les valeurs en double d'un tableau en PHP

Comment puis-je supprimer les valeurs en double d'un tableau en PHP?

Utilisez array_unique () .

Exemple:

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

Utilisation array_values(array_unique($array));

array_unique: pour un tableau unique array_values: pour la réindexation

//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 )

La seule chose qui a fonctionné pour moi est:

$array = array_unique($array, SORT_REGULAR);

Edit: SORT_REGULARconserve le même ordre du tableau d'origine.

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

parfois, ce array_unique()n'est pas le cas, si vous voulez obtenir des éléments uniques ET dupliqués ...

$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

résultats sur

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

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

Nous pouvons créer un tel type de tableau pour utiliser cette dernière valeur qui sera mise à jour en colonne ou en valeur clé et nous obtiendrons une valeur unique du tableau ...

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

Cela prendra en charge les associations de clés et sérialisera les clés pour le nouveau tableau résultant :-)

En fonction de la taille de votre tableau, j'ai trouvé

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

peut être plus rapide que array_unique.

C'est une excellente façon de le faire. Vous voudrez peut-être vous assurer que sa sortie est à nouveau un tableau. Désormais, vous n'affichez que la dernière valeur unique.

Essaye ça:

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

première fois vérifier la valeur dans le tableau et trouver la même valeur l'ignorer

Supprimez les valeurs en double d'un tableau associatif en 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]);
}

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

Il peut y avoir plusieurs façons de procéder, qui sont les suivantes

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

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

Si vous êtes préoccupé par les performances et avez un tableau simple, utilisez:

array_keys(array_flip($array));

C'est plusieurs fois plus rapide que array_unique.

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

essayez ce code court et doux -

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

Production -

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

Ici, j'ai créé un deuxième tableau vide et utilisé une forboucle avec le premier tableau qui a des doublons. Il s'exécutera autant de fois que le nombre du premier tableau. Ensuite, comparé à la position du tableau avec le premier tableau et correspond au fait qu'il a déjà cet élément ou non en utilisant in_array. Sinon, il ajoutera cet élément au deuxième tableau avec 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);

Cela peut être fait grâce à la fonction J'ai fait trois fonctions dupliquées renvoyant les valeurs qui sont dupliquées dans le tableau.

La deuxième fonction simple ne renvoie que les valeurs qui sont simples signifie non répétées dans le tableau et la troisième et la fonction complète renvoient toutes les valeurs mais non dupliquées si une valeur est dupliquée, elle la convertit en simple;

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: Démo

Une alternative à la fonction array_unique ().

Utilisation de l'algorithme de force brute

// [1] Voici notre tableau avec des éléments dupliqués

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

// [2] Conteneur pour le nouveau tableau sans aucun élément dupliqué

$ arr = [];

// [3] récupère la longueur du tableau dupliqué et définit la valeur var len à utiliser pour la boucle for

$ len = count ($ correspond);

// [4] Si correspond à la clé du tableau ($ i) boucle courante L'itération n'est pas disponible dans
// [4] le tableau $ arr puis pousse la valeur de la clé d'itération courante des correspondances [$ i]
// [4] au tableau arr.

pour ($ 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
)

J'ai fait cela sans utiliser aucune fonction.

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