array_uintersect_uassoc — Funktion · PHP-Referenz

Signatur

array_uintersect_uassoc(array $array, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array

Beschreibung

array_uintersect_uassoc berechnet die Schnittmenge mehrerer Arrays, berücksichtigt dabei sowohl die Werte als auch die Schlüssel (Indizes) und verwendet für beide Vergleiche je eine benutzerdefinierte Callback-Funktion. Ein Element aus dem ersten Array wird nur dann in das Ergebnis übernommen, wenn sowohl sein Wert als auch sein Schlüssel in allen weiteren Arrays vorhanden sind – gemessen an den Rückgabewerten der beiden Callback-Funktionen.

Die Wert-Callback ($value_compare_func) und die Schlüssel-Callback ($key_compare_func) müssen jeweils zwei Argumente entgegennehmen und einen Integer zurückgeben: negativ, wenn das erste Argument kleiner ist, 0 bei Gleichheit und positiv, wenn das erste Argument größer ist – analog zu strcmp oder dem Raumschiff-Operator <=>.

Diese Funktion eignet sich besonders, wenn Standard-Vergleiche nicht ausreichen – etwa beim Vergleich von Objekten, case-insensitiven Strings, normalisierten Werten oder komplexen Datenstrukturen, bei denen sowohl Schlüssel als auch Werte nach eigener Logik abgeglichen werden sollen.

Im Gegensatz zu array_uintersect_assoc (das Schlüssel intern vergleicht) oder array_intersect_uassoc (das Werte intern vergleicht) bietet diese Funktion volle Kontrolle über beide Vergleichsoperationen.

Parameter

Name	Typ	Beschreibung
$array Pflicht	array	Das Ausgangsarray, aus dem die Schnittmenge gebildet wird.
$arrays Pflicht	array	Ein oder mehrere Arrays, mit denen das Ausgangsarray verglichen wird. Mindestens ein weiteres Array ist erforderlich.
$value_compare_func Pflicht	callable	Callback-Funktion zum Vergleich der Werte. Erwartet zwei Argumente und gibt einen Integer zurück: `< 0` wenn das erste kleiner ist, `0` bei Gleichheit, `> 0` wenn das erste größer ist.
$key_compare_func Pflicht	callable	Callback-Funktion zum Vergleich der Schlüssel. Erwartet zwei Argumente und gibt einen Integer zurück: `< 0` wenn das erste kleiner ist, `0` bei Gleichheit, `> 0` wenn das erste größer ist.

Rückgabewert

Typ

array

Beschreibung

Gibt ein Array zurück, das alle Elemente aus dem ersten Array enthält, deren Werte und Schlüssel in allen weiteren Arrays vorhanden sind (gemäß den beiden Callback-Funktionen). Schlüssel aus dem Ausgangsarray bleiben erhalten.

Beispiele

Einfacher Vergleich von Strings mit case-insensitiver Logik

<?php
$array1 = ['a' => 'Apfel', 'b' => 'Banane', 'c' => 'Kirsche'];
$array2 = ['A' => 'apfel', 'b' => 'banane', 'D' => 'Dattel'];

$result = array_uintersect_uassoc(
    $array1,
    $array2,
    fn($a, $b) => strcasecmp($a, $b),   // Wertvergleich: case-insensitiv
    fn($a, $b) => strcasecmp($a, $b)    // Schlüsselvergleich: case-insensitiv
);

print_r($result);

Array ( [a] => Apfel [b] => Banane )

Vergleich von Objekten nach Eigenschaft

<?php
class Produkt {
    public function __construct(
        public string $name,
        public float  $preis
    ) {}
}

$lager1 = [
    'p1' => new Produkt('Stuhl', 49.99),
    'p2' => new Produkt('Tisch', 129.99),
    'p3' => new Produkt('Lampe', 19.99),
];

$lager2 = [
    'p1' => new Produkt('Stuhl', 49.99),
    'p2' => new Produkt('Sofa',  299.00),
    'p4' => new Produkt('Lampe', 19.99),
];

// Wertvergleich: nach Name UND Preis
$vergleichWert = fn(Produkt $a, Produkt $b)
    => $a->name <=> $b->name ?: $a->preis <=> $b->preis;

// Schlüsselvergleich: einfacher String-Vergleich
$vergleichKey = fn($a, $b) => strcmp($a, $b);

$schnittmenge = array_uintersect_uassoc(
    $lager1,
    $lager2,
    $vergleichWert,
    $vergleichKey
);

foreach ($schnittmenge as $key => $produkt) {
    echo "$key: {$produkt->name} ({$produkt->preis} €)\n";
}

p1: Stuhl (49.99 €)

// Wichtig · Fallstricke

Reihenfolge der Callbacks: Die beiden Callback-Funktionen müssen als letzte Parameter übergeben werden, wobei die Wert-Callback vor der Schlüssel-Callback steht. Die Anzahl der zu vergleichenden Arrays dazwischen ist variabel.

Leistung: Da zwei benutzerdefinierte Callbacks für jede Vergleichsoperation aufgerufen werden, kann diese Funktion bei sehr großen Arrays merklich langsamer sein als interne Vergleichsfunktionen wie array_intersect_assoc.

Callback-Konsistenz: Die Callback-Funktionen müssen konsistente Ergebnisse liefern (transitiv, antisymmetrisch). Inkonsistente Vergleichslogik kann zu unvorhersehbaren Ergebnissen führen.

Siehe auch

array_intersect array_intersect_assoc array_uintersect array_uintersect_assoc array_intersect_uassoc array_udiff_uassoc