Cómo eliminar valores duplicados de una matriz en PHP

¿Cómo puedo eliminar valores duplicados de una matriz en PHP?

Use array_unique () .

Ejemplo:

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

Utilizar array_values(array_unique($array));

array_unique: para una matriz única array_values: para reindexar

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

Lo único que funcionó para mí es:

$array = array_unique($array, SORT_REGULAR);

Editar: SORT_REGULARmantiene el mismo orden de la matriz original.

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

a veces array_unique()no es el camino, si quieres obtener elementos únicos Y duplicados ...

$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

resultados en

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

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

Podemos crear ese tipo de matriz para usar este último valor se actualizará en columna o valor clave y obtendremos un valor único de la matriz ...

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

Esto se encargará de las asociaciones de claves y serializará las claves para la nueva matriz resultante :-)

Dependiendo del tamaño de su matriz, he encontrado

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

puede ser más rápido que array_unique.

Esa es una excelente manera de hacerlo. Es posible que desee asegurarse de que su salida vuelva a ser una matriz. Ahora solo está mostrando el último valor único.

Prueba esto:

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

verifique el valor por primera vez en la matriz y encontró el mismo valor, ignórelo

Eliminar valores duplicados de una matriz asociativa 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]);
}

Matriz ([0] => aaa-aaa [1] => 12/1/1 [2] => 1.15)

Puede haber varias formas de hacer esto, que son las siguientes

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

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

Si le preocupa el rendimiento y tiene una matriz simple, use:

array_keys(array_flip($array));

Es muchas veces más rápido 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;
}

prueba este breve y dulce código -

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

Salida -

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

Aquí he creado una segunda matriz vacía y he usado un forbucle con la primera matriz que tiene duplicados. Se ejecutará tantas veces como el recuento de la primera matriz. Luego, se compara con la posición de la matriz con la primera matriz y coincide que ya tiene este elemento o no mediante el uso in_array. De lo contrario, agregará ese elemento a la segunda matriz con 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);

Se puede hacer a través de la función que hice tres funciones duplicadas devuelve los valores que están duplicados en la matriz.

La segunda función solo devuelve solo aquellos valores que son una sola media no repetida en la matriz y la tercera función completa devuelve todos los valores pero no se duplican si algún valor está duplicado, lo convierte a 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: Demo

Una alternativa para la función array_unique ().

Usando el algoritmo de fuerza bruta

// [1] Esta es nuestra matriz con elementos duplicados

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

// [2] Contenedor para la nueva matriz sin elementos duplicados

$ arr = [];

// [3] obtener la longitud de la matriz duplicada y establecerla en la variable que se utilizará para el bucle

$ len = cuenta ($ coincide);

// [4] Si coincide con la clave de matriz ($ i), la iteración del bucle actual no está disponible en
// [4] la matriz $ arr luego empuja el valor de la clave de iteración actual de las coincidencias [$ i]
// [4] a la matriz arr.

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

He hecho esto sin usar ninguna función.

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