Wenn ein Array doppelte Werte enthält und man nur die eindeutigen Einträge behalten möchte, ist array_unique() die passende Funktion. Sie durchsucht das Array, entfernt alle Duplikate und gibt ein neues Array mit nur einmaligen Werten zurück. Dabei bleibt jeweils der erste Eintrag erhalten, alle späteren Vorkommen desselben Wertes werden entfernt.
Syntax und Grundlagen
Die Funktion erwartet ein Array und optional einen Flag für den Vergleichsmodus:
array_unique(array $array, int $flags = SORT_STRING): array
Der Rückgabewert ist ein neues Array ohne Duplikate. Die Schlüssel aus dem Original-Array bleiben erhalten, was zu Lücken in den numerischen Indizes führen kann. Standardmäßig werden die Werte als Strings verglichen (SORT_STRING).
Beispiel: Duplikate aus einem numerischen Array entfernen
Im einfachsten Fall übergibt man ein Array mit doppelten Einträgen und erhält die bereinigte Version zurück:
<?php
$farben = ["rot", "blau", "grün", "rot", "gelb", "blau"];
$eindeutig = array_unique($farben);
print_r($eindeutig);
?>
Ausgabe:
Array
(
[0] => rot
[1] => blau
[2] => grün
[4] => gelb
)
Die doppelten Einträge "rot" (Index 3) und "blau" (Index 5) wurden entfernt. Beachte, dass die Schlüssel [3] und [5] fehlen. Das Array hat Lücken in den Indizes. Um die Ausgabe lesbar zu machen, nutzen wir hier die print_r()-Funktion.
Neuindizierung mit array_values()
Nach dem Entfernen von Duplikaten hat das Ergebnis-Array oft Lücken in den Indizes. Das kann bei json_encode() oder Zählschleifen Probleme verursachen, weil PHP das Array dann als Objekt statt als Liste kodiert. Mit array_values() lassen sich die Indizes lückenlos neu vergeben:
<?php
$zahlen = [10, 20, 30, 10, 20];
$eindeutig = array_unique($zahlen);
print_r($eindeutig);
/* Array ( [0] => 10 [1] => 20 [2] => 30 ) */
/* Neu indizieren */
$clean = array_values($eindeutig);
print_r($clean);
/* Array ( [0] => 10 [1] => 20 [2] => 30 ) */
?>
In diesem Beispiel sind die Indizes zufällig schon lückenlos. Bei größeren Arrays mit vielen Duplikaten entstehen aber regelmäßig Lücken. Als Faustregel: Wenn das Ergebnis weiterverarbeitet wird (z.B. als JSON-Response), immer array_values() anwenden.
Flags: Vergleichsmodus steuern
array_unique() akzeptiert als zweiten Parameter einen Flag, der bestimmt, wie die Werte verglichen werden:
| Flag | Vergleich | Beispiel |
|---|
SORT_STRING | Als Strings (Standard) | "1" und 1 gelten als gleich |
SORT_REGULAR | Normaler Vergleich | Typ wird berücksichtigt, wie bei == |
SORT_NUMERIC | Als Zahlen | "1" und 1.0 gelten als gleich |
SORT_LOCALE_STRING | Locale-abhängig | Berücksichtigt lokale Zeichensatz-Regeln |
Ein Beispiel mit gemischten Datentypen zeigt den Unterschied:
<?php
$gemischt = ["1", 1, true, 1.0, "01"];
$standard = array_unique($gemischt);
print_r($standard);
/* SORT_STRING: Array ( [0] => 1 [2] => 1 [4] => 01 ) */
$regular = array_unique($gemischt, SORT_REGULAR);
print_r($regular);
/* SORT_REGULAR: Array ( [0] => 1 [4] => 01 ) */
?>
Mit SORT_STRING werden die Werte zuerst in Strings umgewandelt. true wird dabei zu "1", bleibt also als Duplikat von "1" bestehen. "01" ist als String verschieden von "1" und wird beibehalten. Mit SORT_REGULAR fällt zusätzlich true weg, da true == 1 gilt.
Praxisbeispiel: E-Mail-Adressen bereinigen
Ein häufiger Anwendungsfall ist die Bereinigung von Benutzereingaben. Wenn z.B. E-Mail-Adressen aus einem Formular eingelesen werden, können Duplikate mit unterschiedlicher Groß-/Kleinschreibung auftreten. Mit array_map() und array_unique() lässt sich das elegant lösen:
<?php
$emails = [
"Max@Beispiel.de",
"anna@beispiel.de",
"max@beispiel.de",
"ANNA@BEISPIEL.DE",
"peter@firma.de"
];
/* Alle auf Kleinbuchstaben normalisieren */
$normalisiert = array_map('strtolower', $emails);
/* Duplikate entfernen und neu indizieren */
$eindeutig = array_values(array_unique($normalisiert));
print_r($eindeutig);
?>
Ausgabe:
Array
(
[0] => max@beispiel.de
[1] => anna@beispiel.de
[2] => peter@firma.de
)
Durch die Kombination von strtolower() und array_unique() werden auch Duplikate erkannt, die sich nur in der Schreibweise unterscheiden. Das array_values() am Ende sorgt für lückenlose Indizes.
Mehrdimensionale Arrays: Duplikate finden
array_unique() arbeitet nur auf der ersten Ebene eines Arrays. Bei mehrdimensionalen Arrays versucht PHP die Sub-Arrays in Strings umzuwandeln, was nicht zum gewünschten Ergebnis führt. Mit dem Flag SORT_REGULAR lassen sich identische Sub-Arrays aber korrekt erkennen:
<?php
$produkte = [
["name" => "Laptop", "preis" => 999],
["name" => "Maus", "preis" => 29],
["name" => "Laptop", "preis" => 999],
["name" => "Tastatur", "preis" => 79]
];
$eindeutig = array_values(
array_unique($produkte, SORT_REGULAR)
);
print_r($eindeutig);
?>
Ausgabe:
Array
(
[0] => Array
(
[name] => Laptop
[preis] => 999
)
[1] => Array
(
[name] => Maus
[preis] => 29
)
[2] => Array
(
[name] => Tastatur
[preis] => 79
)
)
Das dritte Element (das doppelte Laptop) wurde erkannt und entfernt. SORT_REGULAR vergleicht die Sub-Arrays strukturell, sodass nur wirklich identische Einträge als Duplikate gelten.
Performance-Alternative: array_flip()
Bei sehr großen Arrays (mehrere tausend Einträge) kann array_unique() langsam werden, weil die Funktion intern sortiert. Eine schnellere Alternative ist der Trick mit array_flip():
<?php
$gross = ["a", "b", "c", "a", "d", "b", "e"];
/* Schnelle Deduplizierung */
$eindeutig = array_keys(array_flip($gross));
print_r($eindeutig);
/* Array ( [0] => a [1] => b [2] => c [3] => d [4] => e ) */
?>
array_flip() vertauscht Schlüssel und Werte. Da Schlüssel in PHP eindeutig sein müssen, werden Duplikate automatisch überschrieben. Mit array_keys() holt man anschließend die eindeutigen Werte zurück. Diese Methode funktioniert allerdings nur mit Strings und Integers als Werten, da nur diese als Array-Schlüssel erlaubt sind.
Häufigkeit zählen mit array_count_values()
Manchmal will man nicht nur wissen, welche Werte doppelt sind, sondern auch wie oft sie vorkommen. Dafür gibt es array_count_values():
<?php
$tags = ["php", "mysql", "php", "javascript", "php", "mysql"];
$haeufigkeit = array_count_values($tags);
print_r($haeufigkeit);
/* Array ( [php] => 3 [mysql] => 2 [javascript] => 1 ) */
/* Nur Tags mit mehr als einem Vorkommen */
$duplikate = array_filter(
$haeufigkeit,
function($count) { return $count > 1; }
);
print_r($duplikate);
/* Array ( [php] => 3 [mysql] => 2 ) */
?>
Während array_unique() Duplikate einfach entfernt, gibt array_count_values() einen Überblick über die Verteilung. Zusammen mit array_filter() lassen sich gezielt nur die mehrfach vorhandenen Werte herausfiltern.
Verwandte Tutorials
Das Bereinigen von Arrays ist nur ein Aspekt der Array-Verarbeitung in PHP. Diese Tutorials behandeln verwandte Themen:
Häufige Fragen zu array_unique()
Die folgenden Fragen klären typische Unsicherheiten beim Einsatz von array_unique().
Ist array_unique() case-sensitive?
Ja, array_unique() unterscheidet Groß- und Kleinschreibung. "PHP" und "php" gelten als verschiedene Werte. Für eine case-insensitive Deduplizierung die Werte zuerst mit array_map('strtolower', $array) normalisieren und dann array_unique() anwenden.
Was passiert mit assoziativen Arrays?
array_unique() funktioniert auch mit assoziativen Arrays. Die Schlüssel bleiben erhalten. Bei Duplikaten wird der erste Schlüssel-Wert-Paar behalten, alle späteren Vorkommen desselben Wertes werden entfernt, unabhängig vom Schlüssel.
Kann man die Reihenfolge der Elemente beeinflussen?
array_unique() behält immer das erste Vorkommen eines Wertes. Die Reihenfolge des Eingabe-Arrays bestimmt also, welches Element überlebt. Mit array_reverse() vor array_unique() kann man stattdessen das letzte Vorkommen behalten.
Wie erkennt man mit var_dump(), ob Duplikate entfernt wurden?
Ein Vergleich der Array-Längen vorher und nachher zeigt, ob Duplikate gefunden wurden: count($original) !== count(array_unique($original)). Für eine detaillierte Ausgabe der Struktur eignet sich var_dump(), das auch die Datentypen der einzelnen Werte anzeigt.
