PHP array_unique(): doppelte Werte entfernen

array_unique($array) liefert das Array ohne doppelte Werte. Das erste Vorkommen jedes Werts bleibt unter seinem ursprünglichen Schlüssel stehen, und die späteren Kopien werden verworfen.

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

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

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

Das erste Ergebnis behält die Schlüssel 0, 1, 3: die Positionen, an denen jeder Wert zuerst auftauchte. Setze den Aufruf in array_values(), wenn du eine saubere Liste willst, zum Beispiel vor json_encode.

Wie array_unique entscheidet, dass zwei Werte gleich sind

Standardmäßig wird jeder Wert in einen String umgewandelt, und die Strings werden verglichen. Also zählen 1, "1" und 1.0 als derselbe Wert, und der erste gewinnt. Das zweite Argument ändert den Vergleich.

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

Mit dem Standard bleibt "01" erhalten, weil der String "01" nicht der String "1" ist. Mit SORT_REGULAR fällt er weg, weil "01" == 1 wahr ist. Der lockere Vergleich lässt außerdem den Boolean true zu jedem nicht leeren Wert passen. Prüfe bei gemischten Typen die Ausgabe, bevor du dich darauf verlässt; die Seite zu Vergleichsoperatoren erklärt die Regeln.

Duplikate ohne Groß- und Kleinschreibung entfernen

array_unique unterscheidet Groß- und Kleinschreibung: "PHP" und "php" sind verschieden. Um sie als Duplikate zu behandeln, aber die ursprüngliche Schreibweise des ersten zu behalten, ermittelst du die eindeutigen Schlüssel auf einer kleingeschriebenen Kopie und behältst diese Schlüssel aus dem 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 baut eine kleingeschriebene Kopie mit denselben Schlüsseln, array_unique behält die Schlüssel der ersten Vorkommen, und array_intersect_key holt diese Schlüssel aus dem ursprünglichen Array. Für Text mit Umlauten, Akzenten oder Japanisch verwendest du mb_strtolower statt strtolower.

array_unique bei einem mehrdimensionalen Array

Ohne Flag wandelt array_unique jede Zeile in den String "Array" um, sodass alle Zeilen gleich aussehen und nur die erste übrig bleibt, mit einer Warnung „Array to string conversion“ für jede Zeile. Übergib SORT_REGULAR, um ganze Zeilen zu vergleichen. Um eine Zeile pro Wert eines einzelnen Felds zu behalten, ist array_column mit null und einem Index-Schlüssel einfacher.

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

Der zweite Ansatz behält für jede E-Mail die letzte Zeile, weil jede spätere Zeile die frühere unter demselben Schlüssel überschreibt. Die Seite zu array_column erklärt den Index-Schlüssel im Detail.

Doppelte Werte finden und zählen

array_count_values() liefert, wie oft jeder Wert vorkommt. Filtere das nach Zählungen über eins, und du hast die Duplikate.

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

Die letzte Prüfung ist ein gängiger Einzeiler, um zu testen, ob ein Array überhaupt Duplikate hat.

Schnellere eindeutige Werte bei großen Arrays

array_unique wandelt jeden Wert vor dem Vergleich in einen String um, was bei Tausenden Werten in Ordnung ist. Bei einer großen Liste von Ganzzahlen oder Strings ist Umdrehen schneller: Werte werden zu Schlüsseln, und Schlüssel sind per Definition eindeutig.

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

Die Zeiten ändern sich von Durchlauf zu Durchlauf, aber die Version mit Umdrehen ist meist um ein Vielfaches schneller. Sie funktioniert nur mit Werten, die Array-Schlüssel sein können (Ganzzahlen und Strings), und numerische Strings wie "5" kommen als Ganzzahlen zurück.