PHP array_unique() : supprimer les doublons d'un tableau

array_unique($array) renvoie le tableau sans les valeurs en double. La première occurrence de chaque valeur reste, sous sa clé d'origine, et les copies suivantes sont abandonnées.

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

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

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

Le premier résultat garde les clés 0, 1, 3 : les positions où chaque valeur est apparue pour la première fois. Entourez l'appel d'array_values() quand vous voulez une liste propre, par exemple avant json_encode.

Comment array_unique décide que deux valeurs sont identiques

Par défaut, chaque valeur est convertie en chaîne et les chaînes sont comparées. Donc 1, "1" et 1.0 comptent comme la même valeur, et la première l'emporte. Le second argument change la comparaison.

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

Avec le défaut, "01" survit car la chaîne "01" n'est pas la chaîne "1". Avec SORT_REGULAR, elle est abandonnée, car "01" == 1 est vrai. La comparaison souple permet aussi au booléen true de correspondre à n'importe quelle valeur non vide. Vérifiez la sortie avant de vous y fier avec des types mélangés ; la page des opérateurs de comparaison explique les règles.

Supprimer les doublons sans tenir compte de la casse

array_unique est sensible à la casse : "PHP" et "php" sont différentes. Pour les traiter comme des doublons tout en gardant l'écriture d'origine de la première, trouvez les clés uniques sur une copie en minuscules et gardez ces clés dans l'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 construit une copie en minuscules avec les mêmes clés, array_unique garde les clés des premières occurrences, et array_intersect_key prend ces clés dans le tableau d'origine. Pour du texte accentué ou japonais, utilisez mb_strtolower à la place de strtolower.

array_unique sur un tableau multidimensionnel

Sans option, array_unique convertit chaque ligne en la chaîne "Array", si bien que toutes les lignes semblent identiques et que seule la première survit, avec un warning « Array to string conversion » pour chaque ligne. Passez SORT_REGULAR pour comparer des lignes entières. Pour garder une ligne par valeur d'un seul champ, array_column avec null et une clé d'index est plus simple.

<?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')));

La seconde approche garde la dernière ligne pour chaque email, car chaque ligne suivante écrase la précédente sous la même clé. La page array_column détaille la clé d'index.

Trouver et compter les valeurs en double

array_count_values() renvoie combien de fois chaque valeur apparaît. Filtrez les comptes supérieurs à un et vous avez les doublons.

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

Le dernier test est une ligne courante pour savoir si un tableau contient le moindre doublon.

Des valeurs uniques plus rapides pour les grands tableaux

array_unique convertit chaque valeur en chaîne avant de comparer, ce qui convient pour des milliers de valeurs. Pour une grande liste d'entiers ou de chaînes, inverser le tableau est plus rapide : les valeurs deviennent des clés, et les clés sont uniques par définition.

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

Les temps changent d'une exécution à l'autre, mais la version avec inversion est généralement plusieurs fois plus rapide. Elle ne fonctionne que pour des valeurs qui peuvent servir de clés (entiers et chaînes), et les chaînes numériques comme "5" reviennent sous forme d'entiers.