eliminar duplicados array multidimensional php

Cómo eliminar valores duplicados de una matriz multidimensional en PHP

Question

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

Ejemplo de matriz:

Array
(
    [0] => Array
    (
        [0] => abc
        [1] => def
    )

    [1] => Array
    (
        [0] => ghi
        [1] => jkl
    )

    [2] => Array
    (
        [0] => mno
        [1] => pql
    )

    [3] => Array
    (
        [0] => abc
        [1] => def
    )

    [4] => Array
    (
        [0] => ghi
        [1] => jkl
    )

    [5] => Array
    (
        [0] => mno
        [1] => pql
    )

)

Answer 1

Aquí hay otra manera. No se guardan variables intermedias.

Usamos esto para duplicar los resultados de una variedad de consultas superpuestas.

$input = array_map("unserialize", array_unique(array_map("serialize", $input)));

Answer 2

Como la gente dice que array_unique() es muy lento, aquí hay un fragmento de código que uso para una matriz multidimensional de un nivel.

$serialized_array = array_map("serialize", $input);

foreach ($serialized_array as $key => $val) {
     $result[$val] = true;
}

$output = array_map("unserialize", (array_keys($result)));

Referencia del primer usuario contribuyó con una nota de la array_unique() array_unique() array_unique()

Answer 3

De otra manera. Conservará las llaves también.

function array_unique_multidimensional($input)
{
    $serialized = array_map(''serialize'', $input);
    $unique = array_unique($serialized);
    return array_intersect_key($input, $unique);
}

Answer 4

Desde 5.2.9 puede usar array_unique() si usa la SORT_REGULAR la SORT_REGULAR manera:

array_unique($array, SORT_REGULAR);

Esto hace que la función compare elementos para la igualdad, como si $a == $b se estuviera utilizando, lo que es perfecto para su caso.

Salida

Array
(
    [0] => Array
        (
            [0] => abc
            [1] => def
        )

    [1] => Array
        (
            [0] => ghi
            [1] => jkl
        )

    [2] => Array
        (
            [0] => mno
            [1] => pql
        )

)

Tenga en cuenta, sin embargo, que la documentación dice:

array_unique() no está diseñado para trabajar en matrices multidimensionales.

Answer 5

He pensado mucho en este problema y he determinado que la solución óptima debe seguir dos reglas.

1. Para la escalabilidad, modifique la matriz en su lugar; sin copiar a una nueva matriz
2. Para el rendimiento, cada comparación debe hacerse solo una vez.

Con eso en mente y dadas todas las peculiaridades de PHP, a continuación se muestra la solución que se me ocurrió. A diferencia de algunas de las otras respuestas, tiene la capacidad de eliminar elementos en función de las claves que desee. Se espera que la matriz de entrada sean teclas numéricas.

$count_array = count($input);
for ($i = 0; $i < $count_array; $i++) {
    if (isset($input[$i])) {
        for ($j = $i+1; $j < $count_array; $j++) {
            if (isset($input[$j])) {
                //this is where you do your comparison for dupes
                if ($input[$i][''checksum''] == $input[$j][''checksum'']) {
                    unset($input[$j]);
                }
            }
        }
    }
}

El único inconveniente es que las teclas no están en orden cuando se completa la iteración. Esto no es un problema si posteriormente usa solo bucles foreach, pero si necesita usar un bucle for, puede poner $input = array_values($input); Después de lo anterior para renumerar las claves.

Answer 6

Los comentarios de los usuarios sobre la documentación de array_unique() tienen muchas soluciones para esto. Aqui esta uno de ellos:

kenrbnsn en rbnsn punto com
27-Sep-2005 12:09

Sin embargo, otro Array_Unique para arreglos multi-demensionados. Solo he probado esto en matrices de dos dimensiones, pero probablemente se podría generalizar para obtener más, o se podría utilizar para usar la recursión.

Esta función utiliza las funciones serialize, array_unique y unserialize para realizar el trabajo.

function multi_unique($array) {
    foreach ($array as $k=>$na)
        $new[$k] = serialize($na);
    $uniq = array_unique($new);
    foreach($uniq as $k=>$ser)
        $new1[$k] = unserialize($ser);
    return ($new1);
}

Esto es de http://ca3.php.net/manual/en/function.array-unique.php#57202 .

Answer 7

Mucha persona me preguntó cómo hacer una matriz multidimensional única. He tomado la referencia de su comentario y me ayuda.

En primer lugar, gracias a @jeromegamez @daveilers por su solución. Pero cada vez que daba la respuesta, me preguntaban cómo funcionaba este ''serializar'' y ''unserialize''. Por eso quiero compartir la razón de esto con usted para que ayude a más personas a comprender el concepto detrás de esto.

Estoy explicando por qué usamos ''serializar'' y ''no serializar'' en los pasos:

Paso 1: Convertir la matriz multidimensional en una matriz unidimensional

Para convertir la matriz multidimensional en una matriz unidimensional, primero genere la representación del flujo de bytes de todos los elementos (incluidas las matrices anidadas) dentro de la matriz. La función serialize () puede generar una representación de flujo de bytes de un valor Para generar una representación de flujo de bytes de todos los elementos, llame a la función serialize () dentro de la función array_map () como una función de devolución de llamada. El resultado será una matriz unidimensional sin importar cuántos niveles tenga la matriz multidimensional.

Paso 2: Hacer los valores únicos.

Para hacer que esta matriz unidimensional sea única, use la función array_unique ().

Paso 3: Revertirlo a la matriz multidimensional

Aunque la matriz ahora es única, los valores se parecen a la representación del flujo de bytes. Para revertirlo a la matriz multidimensional, use la función unserialize ().

$input = array_map("unserialize", array_unique(array_map("serialize", $input)));

Gracias de nuevo por todo esto.

Answer 8

Si "eliminar duplicados" significa "eliminar duplicados, pero dejar uno allí", una solución podría ser aplicar array_unique(...) en la "columna de identificador" primero y luego eliminar en la matriz original todas las claves que tienen sido eliminado de la matriz de columnas:

$array = [
    [
        ''id'' => ''123'',
        ''foo'' => ''aaa'',
        ''bar'' => ''bbb''
    ],
    [
        ''id'' => ''123'',
        ''foo'' => ''ccc'',
        ''bar'' => ''ddd''
    ],
    [
        ''id'' => ''567'',
        ''foo'' => ''eee'',
        ''bar'' => ''fff''
    ]
];

$ids = array_column($array, ''id'');
$ids = array_unique($ids);
$array = array_filter($array, function ($key, $value) use ($ids) {
    return in_array($value, array_keys($ids));
}, ARRAY_FILTER_USE_BOTH);

El resultado es:

Array
(
    [0] => Array
        (
            [id] => 123
            [foo] => aaa
            [bar] => bbb
        )

    [2] => Array
        (
            [id] => 567
            [foo] => eee
            [bar] => fff
        )

)

Answer 9

Si necesita eliminar duplicados en claves específicas, como una ID de mysqli, aquí tiene una función simple.

function search_array_compact($data,$key){
    $compact = [];
    foreach($data as $row){
        if(!in_array($row[$key],$compact)){
            $compact[] = $row;
        }
    }
    return $compact;
}

Puntos de bonificación Puede pasar una serie de claves y agregar un foreach externo, pero será 2 veces más lento por clave adicional.

Answer 10

Si tienes una matriz como esta

data = array
(
[0] => array
(
    [subject] => a
    [object] => c
),
[1] => array
(
    [subject] => b
    [object] => d
),
[2] => array
(
    [subject] => d
    [object] => b
),
[3] => array
(
    [subject] => d
    [object] => c
),
[4] => array
(
    [subject] => c
    [object] => a
),
[5] => array
(
    [subject] => c
    [object] => d
)
)

y quieres obtener matrices como esta:

data = array
(
[0] => array
(
    [subject] => a
    [object] => c
),
[1] => array
(
    [subject] => b
    [object] => d
),
[2] => array
(
    [subject] => d
    [object] => c
)
)

o

data = array
(
[0] => array
(
    [subject] => d
    [object] => b
),
[1] => array
(
    [subject] => c
    [object] => a
),
[2] => array
(
    [subject] => c
    [object] => d
)
)

un siguiente código puede ayudar

    $data1 = array();
    $data1 = $data;
    for($q=0;$q<count($data);$q++)
    {
            for($p=0;$p<count($data1);$p++)
            {
                    if (($data[$q]["subject"] == $data1[$p]["object"]) && ($data[$q]["object"] == $data1[$p]["subject"]))
                    {
                            $data1[$p]["subject"] = $data[$q]["subject"];
                            $data1[$p]["object"] = $data[$q]["object"];
                    }
            }
    }
    $data1 = array_values(array_map("unserialize", array_unique(array_map("serialize", $data1))));
    $data = $data1;

Answer 11

Si tienes una matriz como esta:

(usuarios es el nombre de la matriz)

Array=>
 [0] => (array)
   ''user'' => ''john''
   ''age'' => ''23''
 [1] => (array)
  ''user'' => ''jane''
  ''age'' => ''20''
 [2]=> (array)
  ''user'' => ''john''
  ''age'' => ''23''

y quieres borrar duplicados ... entonces:

$serialized = array();
for ($i=0; $i < sizeof($users); $i++) { 
  $test = in_array($users[''user''], $serialized);
    if ($test == false) {
      $serialized[] = $users[''user''];
    }
 }

puede ser una solución: P

Answer 12

Simplemente use la opción SORT_REGULAR como segundo parámetro.

$uniqueArray = array_unique($array, SORT_REGULAR);

Answer 13

Tuve un problema similar pero encontré una solución 100% funcional para él.

<?php
    function super_unique($array,$key)
    {
       $temp_array = [];
       foreach ($array as &$v) {
           if (!isset($temp_array[$v[$key]]))
           $temp_array[$v[$key]] =& $v;
       }
       $array = array_values($temp_array);
       return $array;

    }


$arr="";
$arr[0][''id'']=0;
$arr[0][''titel'']="ABC";
$arr[1][''id'']=1;
$arr[1][''titel'']="DEF";
$arr[2][''id'']=2;
$arr[2][''titel'']="ABC";
$arr[3][''id'']=3;
$arr[3][''titel'']="XYZ";

echo "<pre>";
print_r($arr);
echo "unique*********************<br/>";
print_r(super_unique($arr,''titel''));

?>

Answer 14

Una alternativa para serializar y única.

$test = [
    [''abc'',''def''],
    [''ghi'',''jkl''],
    [''mno'',''pql''],
    [''abc'',''def''],
    [''ghi'',''jkl''],
    [''mno'',''pql''],
];

$result = array_reduce(
    $test,
    function($carry,$item){
        if(!in_array($item,$carry)) {
            array_push($carry,$item);
        }
        return $carry;
    },
    []
);

var_dump($result);

/*
 php unique.php
array(3) {
    [0] =>
        array(2) {
            [0] =>
                string(3) "abc"
            [1] =>
                string(3) "def"
        }
    [1] =>
        array(2) {
            [0] =>
                string(3) "ghi"
            [1] =>
                string(3) "jkl"
        }
    [2] =>
        array(2) {
              [0] =>
                  string(3) "mno"
              [1] =>
                  string(3) "pql"
        }
}

* /

Answer 15

Una manera muy fácil y lógica de crear una matriz de múltiples dimensiones es la siguiente,

Si tienes una matriz como esta:

Array
(
    [Key1] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value1
            [3] => Value3
            [4] => Value1
        )
    [Key2] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value1
            [3] => Value3
            [4] => Value4
        )
)

Utilice foreach para resolver esto:

foreach($array as $k=>$v){
    $unique=array_unique($v);
    $array[$k]=$unique;
}

Te dará el siguiente resultado:

Array
(
    [Key1] => Array
        (
            [0] => Value1
            [1] => Value2
            [3] => Value3
        )
    [Key2] => Array
        (
            [0] => Value1
            [1] => Value2
            [3] => Value3
            [4] => Value4
        )
)

y si quieres reorganizar el orden de las teclas,

foreach($array as $k=>$v){
    $unique= array_values(array_unique($v));
    $array[$k]=$unique;
}

Esta operación le dará valores clave ordenados como este:

Array
(
    [Key1] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value3
        )
    [Key2] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value3
            [3] => Value4
        )
)

Espero que esto lo aclare todo.

Answer 16

Una solución fácil de leer, probablemente no la más eficiente:

function arrayUnique($myArray){
    if(!is_array($myArray))
        return $myArray;

    foreach ($myArray as &$myvalue){
        $myvalue=serialize($myvalue);
    }

    $myArray=array_unique($myArray);

    foreach ($myArray as &$myvalue){
        $myvalue=unserialize($myvalue);
    }

    return $myArray;

} 

Answer 17

Array
(
    [0] => Array
        (
            [id] => 1
            [name] => john
        )

    [1] => Array
        (
            [id] => 2
            [name] => smith
        )

    [2] => Array
        (
            [id] => 3
            [name] => john
        )

    [3] => Array
        (
            [id] => 4
            [name] => robert
        )

)

$temp = array_unique(array_column($array, ''name''));
$unique_arr = array_intersect_key($array, $temp);

Esto eliminará los nombres duplicados de la matriz. único por clave