PHP array_unique(): rimuovere i valori duplicati

array_unique($array) restituisce l'array senza i valori duplicati. La prima occorrenza di ogni valore resta, sotto la sua chiave originale, e le copie successive vengono scartate.

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

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

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

Il primo risultato mantiene le chiavi 0, 1, 3: le posizioni in cui ogni valore è comparso per la prima volta. Racchiudi la chiamata in array_values() quando vuoi una lista pulita, per esempio prima di json_encode.

Come array_unique decide che due valori sono uguali

Di default ogni valore viene convertito in stringa e le stringhe vengono confrontate. Quindi 1, "1" e 1.0 contano come lo stesso valore, e vince il primo. Il secondo argomento cambia il confronto.

<?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 il default, "01" sopravvive perché la stringa "01" non è la stringa "1". Con SORT_REGULAR viene scartato, perché "01" == 1 è vero. Il confronto debole fa anche corrispondere il booleano true a qualsiasi valore non vuoto. Controlla l'output prima di farci affidamento con tipi misti; la pagina sugli operatori di confronto spiega le regole.

Rimuovere i duplicati ignorando maiuscole e minuscole

array_unique distingue maiuscole e minuscole: "PHP" e "php" sono diversi. Per trattarli come duplicati mantenendo la grafia originale del primo, trova le chiavi uniche su una copia in minuscolo e tieni quelle chiavi dall'originale.

<?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 costruisce una copia in minuscolo con le stesse chiavi, array_unique tiene le chiavi delle prime occorrenze e array_intersect_key estrae quelle chiavi dall'array originale. Per il testo accentato o giapponese, usa mb_strtolower al posto di strtolower.

array_unique su un array multidimensionale

Senza flag, array_unique converte ogni riga nella stringa "Array", quindi tutte le righe sembrano identiche e sopravvive solo la prima, con un warning "Array to string conversion" per ogni riga. Passa SORT_REGULAR per confrontare le righe intere. Per tenere una riga per ogni valore di un singolo campo, array_column con null e una chiave indice è più semplice.

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

Il secondo approccio tiene l'ultima riga per ogni email perché ogni riga successiva sovrascrive la precedente sotto la stessa chiave. La pagina su array_column spiega la chiave indice in dettaglio.

Trovare e contare i valori duplicati

array_count_values() restituisce quante volte compare ogni valore. Filtralo per i conteggi maggiori di uno e hai i duplicati.

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

L'ultimo controllo è una riga comune per verificare se un array ha dei duplicati.

Valori unici più veloci per array grandi

array_unique converte ogni valore in stringa prima di confrontarlo, il che va bene per migliaia di valori. Per una lunga lista di interi o stringhe, invertire l'array è più veloce: i valori diventano chiavi, e le chiavi sono uniche per definizione.

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

I tempi cambiano da un'esecuzione all'altra, ma la versione con il flip è di solito parecchie volte più veloce. Funziona solo con valori che possono essere chiavi di array (interi e stringhe), e le stringhe numeriche come "5" tornano come interi.