PHP array_unique(): eliminar valores duplicados

array_unique($array) devuelve el array sin valores duplicados. La primera aparición de cada valor se queda, bajo su clave original, y las copias posteriores se descartan.

<?php
$tags = ["php", "arrays", "php", "tips", "arrays", "php"];

$unique = array_unique($tags);
print_r($unique);

print_r(array_values($unique)); // renumbered 0, 1, 2

El primer resultado conserva las claves 0, 1, 3: las posiciones donde apareció por primera vez cada valor. Envuelve la llamada en array_values() cuando quieras una lista limpia, por ejemplo antes de json_encode.

Cómo decide array_unique que dos valores son iguales

Por defecto, cada valor se convierte en cadena y se comparan las cadenas. Así, 1, "1" y 1.0 cuentan como el mismo valor, y gana el primero. El segundo argumento cambia la comparación.

<?php
$mixed = [1, "1", 1.0, true, "01", 2];

var_dump(array_unique($mixed));                // compared as strings
var_dump(array_unique($mixed, SORT_REGULAR));  // compared with ==
var_dump(array_unique(["10", "1e1", "010"], SORT_NUMERIC));

Con el valor por defecto, "01" sobrevive porque la cadena "01" no es la cadena "1". Con SORT_REGULAR se descarta, porque "01" == 1 es verdadero. La comparación flexible también hace que el booleano true coincida con cualquier valor no vacío. Revisa la salida antes de confiar en ella con tipos mezclados; la página de operadores de comparación explica las reglas.

Quitar duplicados sin distinguir mayúsculas y minúsculas

array_unique distingue mayúsculas y minúsculas: "PHP" y "php" son distintos. Para tratarlos como duplicados pero conservar la escritura original del primero, busca las claves únicas en una copia en minúsculas y quédate con esas claves del original.

<?php
$languages = ["PHP", "Python", "php", "Go", "python", "GO", "Rust"];

$keys = array_unique(array_map('strtolower', $languages));
$result = array_values(array_intersect_key($languages, $keys));

print_r($result);

array_map construye una copia en minúsculas con las mismas claves, array_unique conserva las claves de las primeras apariciones y array_intersect_key toma esas claves del array original. Para texto con tildes o japonés, usa mb_strtolower en lugar de strtolower.

array_unique con un array multidimensional

Sin flag, array_unique convierte cada fila en la cadena "Array", así que todas las filas parecen idénticas y solo sobrevive la primera, con un warning "Array to string conversion" por cada fila. Pasa SORT_REGULAR para comparar filas enteras. Para conservar una fila por cada valor de un solo campo, es más sencillo array_column con null y una clave de índice.

<?php
$signups = [
    ["email" => "ada@example.com", "plan" => "free"],
    ["email" => "bob@example.com", "plan" => "pro"],
    ["email" => "ada@example.com", "plan" => "free"],
    ["email" => "ada@example.com", "plan" => "pro"],
];

// Exact duplicate rows removed
print_r(array_unique($signups, SORT_REGULAR));

// One row per email: the last row for each email wins
print_r(array_values(array_column($signups, null, 'email')));

El segundo enfoque conserva la última fila de cada email porque cada fila posterior sobrescribe a la anterior bajo la misma clave. La página de array_column explica la clave de índice en detalle.

Encontrar y contar valores duplicados

array_count_values() devuelve cuántas veces aparece cada valor. Filtra eso por los recuentos mayores que uno y tienes los duplicados.

<?php
$votes = ["red", "blue", "red", "green", "blue", "red"];

$counts = array_count_values($votes);
print_r($counts);

$duplicates = array_keys(array_filter($counts, fn($n) => $n > 1));
echo "Duplicated: " . implode(", ", $duplicates) . "\n";

echo count($votes) === count(array_unique($votes))
    ? "No duplicates\n"
    : "Has duplicates\n";

La última comprobación es una línea habitual para saber si un array tiene algún duplicado.

Valores únicos más rápido con arrays grandes

array_unique convierte cada valor en cadena antes de comparar, lo que va bien con miles de valores. Con una lista grande de enteros o cadenas, invertir el array es más rápido: los valores se convierten en claves, y las claves son únicas por definición.

<?php
$ids = [];
for ($i = 0; $i < 200000; $i++) {
    $ids[] = $i % 1000;
}

$start = hrtime(true);
$a = array_unique($ids);
$t1 = (hrtime(true) - $start) / 1e6;

$start = hrtime(true);
$b = array_keys(array_flip($ids));
$t2 = (hrtime(true) - $start) / 1e6;

echo count($a), " unique values with array_unique\n";
echo count($b), " unique values with array_keys(array_flip())\n";
printf("array_unique: %.1f ms, array_flip: %.1f ms\n", $t1, $t2);

Los tiempos cambian de una ejecución a otra, pero la versión con flip suele ser varias veces más rápida. Solo funciona con valores que pueden ser claves de array (enteros y cadenas), y las cadenas numéricas como "5" vuelven como enteros.