Wer in PHP mit Arrays arbeitet, merkt schnell: Irgendwann reichen die Standardfunktionen wie sort() oder asort() nicht mehr aus. Zumindest ging es mir so, als ich vor der Aufgabe stand, eine komplexe Datenstruktur exakt nach eigenen Regeln zu sortieren. Genau an diesem Punkt wird usort() zum Gamechanger. Mit dieser Funktion legst du selbst fest, wie PHP die Elemente eines Arrays anordnet – und das gibt dir eine enorme Freiheit, egal ob du einfache Listen, assoziative Arrays oder sogar Objekt-Arrays sortieren willst.

Was ist usort() und warum solltest du die Funktion kennen?

Mit den Bordmitteln von PHP bekommst du zwar schnell Ordnung in ein Array, aber sobald die Sortierung von einer bestimmten Eigenschaft, einem Unterwert oder gar mehreren Kriterien abhängt, ist Schluss mit den Standardwerkzeugen. Hier übernimmt usort(): Sie ermöglicht dir, eine eigene Vergleichsfunktion zu schreiben – also selbst zu definieren, nach welchen Kriterien PHP die Elemente sortiert. Das zahlt sich gerade bei Daten aus, die aus mehr als nur simplen Zahlen oder Zeichenketten bestehen.

Was macht usort() anders als sort(), asort() & Co.?

Die typischen Funktionen wie sort() oder asort() sortieren nach festen Vorgaben – entweder nach dem Wert oder nach dem Schlüssel, aber immer stur nach einer Regel. Möchtest du selbst entscheiden, wie verglichen wird, bist du aufgeschmissen. Bei usort() übergibst du stattdessen eine eigene Funktion, die entscheidet, was “größer”, “gleich” oder “kleiner” ist. Damit hast du es selbst in der Hand.

Wie flexibel ist die benutzerdefinierte Sortierung mit usort()?

usort() zeigt seine Stärke, wenn es um flexible Sortierungen geht: Du entscheidest selbst, wie sortiert wird – ganz gleich, ob es sich um Zahlen, Zeichenketten, verschachtelte Arrays oder Objektlisten handelt. Mit der richtigen Vergleichsfunktion kannst du sogar nach beliebig tiefen Eigenschaften oder mehreren Kriterien gleichzeitig sortieren. So hast du die Kontrolle, selbst bei komplexen Datenstrukturen.

Grundlagen der usort() Funktion

Bevor du loslegst und eigene Sortierregeln definierst, solltest du verstehen, wie usort() grundsätzlich arbeitet. Die Funktion ist schon seit Ewigkeiten im PHP-Kern und funktioniert ab Version 4 – sie ist also ein echtes Standardwerkzeug.

Syntax und Funktionssignatur: usort(array &$array, callable $callback): true

So sieht die Signatur aus:

usort(array &$aArray, callable $fVergleichsfunktion): true 

Die Funktion erwartet ein Array (als Referenz!) sowie eine Callback-Funktion, die den Vergleich übernimmt.

Parameter erklärt:

• $aArray: Das Array, das sortiert werden soll. Es wird per Referenz übergeben, das heißt, die Sortierung erfolgt direkt am Original.
• $fVergleichsfunktion: Deine benutzerdefinierte Funktion, mit der PHP zwei Elemente des Arrays vergleicht.

Rückgabewert: Erklären, dass usort() immer true zurückgibt (in PHP 8.2+, vorher bool).

Ab PHP 8.2 gibt usort() immer true zurück – unabhängig davon, ob die Sortierung erfolgreich war oder nicht. In älteren Versionen wird ein boolescher Wert zurückgegeben.

Wichtige Hinweise:

• usort() sortiert das Array an Ort und Stelle (keine Kopie).
• Schlüssel werden neu indiziert (beginnend bei 0). Alte Schlüssel gehen verloren.
• Das ursprüngliche Array ändert sich direkt und bekommt neue fortlaufende Indizes ab 0. Diese Veränderung kann wichtig sein, wenn du die Originalschlüssel noch brauchst.

Das Herzstück: Die benutzerdefinierte Vergleichsfunktion (Callback)

Die Stärke von usort() liegt in der Vergleichsfunktion. Hier legst du fest, wie PHP jeweils zwei Elemente aus deinem Array zueinander bewertet.

Signatur der Callback-Funktion: callback(mixed $a, mixed $b): int

Die Callback-Funktion muss zwei Parameter akzeptieren und einen Integer zurückgeben:

function iVergleich($mA, $mB): int 

Erklärung der Parameter $mA und $mB

PHP ruft deine Funktion für jeweils zwei beliebige Elemente im Array auf. $mA und $mB stehen dabei für diese beiden Elemente.

Die Logik des Rückgabewerts

• Ein negativer Integer (-1): $mA soll vor $mB stehen.
• 0: Beide Elemente gelten als gleichwertig – ihre Reihenfolge bleibt erhalten (sofern die Sortierung stabil ist).
• Ein positiver Integer (1): $mA soll nach $mB einsortiert werden.

Ausführliche Beispiele für die Callback-Logik

Hier ein einfaches Beispiel für den Vergleich von Zahlen:

function iVergleich($iErstes, $iZweites): int 


{ 


 /** Wenn $iErstes kleiner als $iZweites ist, kommt es nach vorne */ 


 if ($iErstes < $iZweites) { 


 return -1; 


 } 


 if ($iErstes > $iZweites) { 


 return 1; 


 } 
 return 0; 


} 


/** Demo-Ausgabe */ 


$aTestfaelle = [ 


 [5, 10], 


 [10, 5], 


 [7, 7], 


 [-3, 2], 


 [2, -3] 


]; 


 
foreach ($aTestfaelle as $aFall) { 


 $iErstes = $aFall[0]; 


 $iZweites = $aFall[1]; 


 $iErgebnis = iVergleich($iErstes, $iZweites); 


 echo "Vergleich ($iErstes, $iZweites): Rückgabewert = $iErgebnisn"; 


} 

Ausgabe:

Vergleich (5, 10): Rückgabewert = -1 


Vergleich (10, 5): Rückgabewert = 1 


Vergleich (7, 7): Rückgabewert = 0 


Vergleich (-3, 2): Rückgabewert = -1 


Vergleich (2, -3): Rückgabewert = 1 

Für Strings solltest du auf Vergleichsfunktionen wie strcmp() zurückgreifen:

function iVergleichString($sA, $sB): int 


{ 


 return strcmp($sA, $sB); 


} 


/** 


 * Demodaten für iVergleichString 


 */ 
$aTestdaten = [ 


 ['sA' => 'Apfel', 'sB' => 'Apfel'], 


 ['sA' => 'Apfel', 'sB' => 'Banane'], 


 ['sA' => 'Banane', 'sB' => 'Apfel'], 


 ['sA' => 'apfel', 'sB' => 'Apfel'], 


 ['sA' => '', 'sB' => ''], 


 ['sA' => '123', 'sB' => '1234'], 


 ['sA' => 'Test', 'sB' => 'Testfall'], 


 ['sA' => 'Zebra', 'sB' => 'Zebra'], 


 ['sA' => 'Straße', 'sB' => 'Strasse'], 


 ['sA' => 'Alpha', 'sB' => 'Alpha '], 


]; 


 
foreach ($aTestdaten as $oTest) { 


 $iErgebnis = iVergleichString($oTest['sA'], $oTest['sB']); 


 echo "Vergleich: '{$oTest['sA']}' vs. '{$oTest['sB']}' → Ergebnis: {$iErgebnis}n"; 


} 

Ausgabe:

Vergleich: 'Apfel' vs. 'Apfel' → Ergebnis: 0 


Vergleich: 'Apfel' vs. 'Banane' → Ergebnis: -1 


Vergleich: 'Banane' vs. 'Apfel' → Ergebnis: 1 


Vergleich: 'apfel' vs. 'Apfel' → Ergebnis: 32 


Vergleich: '' vs. '' → Ergebnis: 0 


Vergleich: '123' vs. '1234' → Ergebnis: -1 


Vergleich: 'Test' vs. 'Testfall' → Ergebnis: -1 


Vergleich: 'Zebra' vs. 'Zebra' → Ergebnis: 0 


Vergleich: 'Straße' vs. 'Strasse' → Ergebnis: 20480 


Vergleich: 'Alpha' vs. 'Alpha ' → Ergebnis: -1 

Der Spaceship-Operator (<=>) als Vereinfachung

Mit PHP 7 kam der Spaceship-Operator <=>. Er gibt direkt -1, 0 oder 1 zurück und macht Vergleichsfunktionen extrem kurz.

function iVergleich($mA, $mB): int 


{ 


 return $mA <=> $mB; 


} 


// Demo-Daten für Vergleich 


$aTestdaten = [ 


 [5, 8], 


 [10, 2], 


 [3, 3], 


 ['apfel', 'birne'], 


 ['zebra', 'affe'], 


 ['abc', 'abc'], 


 [5.0, 5], 


 [null, 0], 


 [true, false], 


 [false, false], 


]; 
 
foreach ($aTestdaten as $aWerte) { 


 $iErgebnis = iVergleich($aWerte[0], $aWerte[1]); 


 echo 'iVergleich(' . var_export($aWerte[0], true) . ', ' . var_export($aWerte[1], true) . ') = ' . $iErgebnis . PHP_EOL; 


} 

Ausgabe:

iVergleich(5, 8) = -1 


iVergleich(10, 2) = 1 


iVergleich(3, 3) = 0 


iVergleich('apfel', 'birne') = -1 


iVergleich('zebra', 'affe') = 1 


iVergleich('abc', 'abc') = 0 


iVergleich(5.0, 5) = 0 


iVergleich(NULL, 0) = 0 


iVergleich(true, false) = 1 


iVergleich(false, false) = 0 

Mit diesem Operator kannst du Zahlen, Strings und sogar komplexere Strukturen bequem vergleichen.

Praktische Anwendungsbeispiele für usort()

Wie sieht das in der Praxis aus? Hier findest du typische und fortgeschrittene Anwendungsfälle.

Beispiel 1: Sortieren eines einfachen Arrays (Zahlen/Strings)

Zuerst ein Zahlenarray, klassisch mit einer eigenen Funktion:

$aZahlen = [3, 1, 4, 2, 5]; 


usort($aZahlen, function($iA, $iB) { 


 /** Vergleich der Zahlen */ 


 return $iA - $iB; 


}); 


/** Ergebnis: [1, 2, 3, 4, 5] */ 

Oder mit dem Spaceship-Operator:

$aZahlen = [3, 1, 4, 2, 5]; 


usort($aZahlen, function($iA, $iB) { 


 return $iA <=> $iB; 


}); 

Für Strings funktioniert das Prinzip ähnlich:

$aNamen = ['Sven', 'Anna', 'Bernd', 'Heike']; 


usort($aNamen, function($sA, $sB) { 


 return strcmp($sA, $sB); 


}); 

Beispiel 2: Sortieren eines Arrays von assoziativen Arrays nach einem spezifischen Schlüssel

Oft möchtest du nach einem Wert in einem assoziativen Array sortieren:

$aPersonen = [ 


 ['name' => 'Anna', 'alter' => 28], 


 ['name' => 'Bernd', 'alter' => 22], 


 ['name' => 'Heike', 'alter' => 35], 


]; 


usort($aPersonen, function($oA, $oB) { 


 /** Sortierung nach 'alter' */ 


 return $oA['alter'] <=> $oB['alter']; 


}); 

Beispiel 3: Sortieren eines Arrays von Objekten nach einer spezifischen Eigenschaft

Für Objekte funktioniert es ebenso – du greifst einfach auf die gewünschte Eigenschaft zu:

class oPerson { 


 public $sName; 


 public $iAlter; 
 
 public function __construct($sName, $iAlter) { 


 $this->sName = $sName; 


 $this->iAlter = $iAlter; 


 } 


} 
 
$aPersonen = [ 


 new oPerson('Anna', 28), 


 new oPerson('Bernd', 22), 


 new oPerson('Heike', 35), 


]; 
 
usort($aPersonen, function($oA, $oB) { 


 /** Sortierung nach Eigenschaft iAlter */ 


 return $oA->iAlter <=> $oB->iAlter; 


}); 

Beispiel 4 (Fortgeschritten): Sortieren nach mehreren Kriterien

Du kannst auch komplexere Sortierungen aufbauen. Wenn zum Beispiel der Nachname gleich ist, kannst du als zweites Kriterium den Vornamen nehmen:

$aLeute = [ 


 ['vorname' => 'Anna', 'nachname' => 'Meier'], 


 ['vorname' => 'Bernd', 'nachname' => 'Schulz'], 


 ['vorname' => 'Bernd', 'nachname' => 'Meier'], 


]; 
 
usort($aLeute, function($oA, $oB) { 


 /** Erst nach Nachname, dann nach Vorname sortieren */ 


 $iVergleichNachname = strcmp($oA['nachname'], $oB['nachname']); 


 if ($iVergleichNachname !== 0) { 


 return $iVergleichNachname; 


 } 


 return strcmp($oA['vorname'], $oB['vorname']); 


}); 

Beispiel 5: Verwendung von Closures (Anonymen Funktionen) und Arrow Functions (PHP 7.4+)

Seit PHP 7.4 kannst du Arrow Functions nutzen, um deinen Code noch kompakter zu machen:

$aNamen = ['Anna', 'Sven', 'Bernd', 'Heike']; 


usort($aNamen, fn($sA, $sB) => strcmp($sA, $sB)); 

Auch mit assoziativen Arrays lässt sich das elegant schreiben:

$aProdukte = [ 


 ['name' => 'Laptop', 'preis' => 999], 


 ['name' => 'Monitor', 'preis' => 199], 


 ['name' => 'Tastatur', 'preis' => 49], 


]; 


usort($aProdukte, fn($oA, $oB) => $oA['preis'] <=> $oB['preis']); 

Wichtige Überlegungen und Fallstricke

Auch wenn usort() mächtig ist, gibt es einige Besonderheiten und Stolperfallen, die du kennen solltest.

Die Auswirkungen der Referenzübergabe auf das Original-Array

Weil das Array per Referenz übergeben wird, arbeitest du immer direkt am Original. Eine Kopie musst du explizit selbst anlegen, wenn du das ursprüngliche Array behalten willst.

Das Zurücksetzen der Array-Schlüssel und wann dies relevant ist

usort() nummeriert die Schlüssel deines Arrays neu durch – ab 0 aufwärts. Das solltest du bedenken, wenn du Wert auf die alten Schlüssel legst.

Vorsicht bei nicht-ganzzahligen Rückgabewerten aus der Callback-Funktion (Typ-Jonglierprobleme vor PHP 8.0)

Deine Vergleichsfunktion sollte immer einen Integer-Wert liefern! Andernfalls kann es zu unerwarteten Ergebnissen oder sogar Fehlern kommen, insbesondere bei älteren PHP-Versionen.

Verhalten bei gleichen Elementen (Stabilität)

Offiziell garantiert PHP keine stabile Sortierung mit usort(). In der Praxis bleibt die Reihenfolge bei Gleichheit oft erhalten, darauf verlassen solltest du dich aber nicht.

Performance-Hinweise (bei sehr großen Arrays oder komplexen Vergleichen)

Da PHP für die Sortierung intern viele Vergleiche durchführt, kann eine ineffiziente Callback-Funktion zu merklichen Performance-Einbußen führen, vor allem bei großen Arrays.

Vergleich mit verwandten PHP-Sortierfunktionen

Es gibt noch weitere Sortierfunktionen mit eigenen Anwendungsfällen.

Wann benutzt man usort()? (Sortierung nach Werten, Schlüssel neu indizieren)

Setze usort() ein, wenn du ein Array nach komplexen oder individuellen Kriterien sortieren willst und dir die Schlüssel dabei egal sind.

Wann benutzt man uasort()? (Sortierung nach Werten, Schlüsselassoziation beibehalten)

Nutze uasort(), wenn du ähnlich flexibel nach Werten sortieren willst, aber die Zuordnung zwischen Schlüssel und Wert erhalten bleiben soll.

Wann benutzt man uksort()? (Sortierung nach Schlüsseln)

Verwende uksort(), wenn die Reihenfolge der Schlüssel entscheidend ist und du eine eigene Sortierlogik für die Schlüssel brauchst.

Hinweis auf andere Standard-Sortierfunktionen (sort(), rsort(), asort(), arsort(), ksort(), krsort())

Manchmal reicht dir die Standard-Sortierung völlig aus. Möchtest du ein Array einfach nur alphabetisch, numerisch oder schlicht auf- oder absteigend sortieren, dann erledigen Funktionen wie sort(), asort() oder ksort() die Arbeit – ganz ohne eigene Vergleichslogik. Diese Funktionen sind unkompliziert, schnell implementiert. Diese bieten dir für die meisten Alltagsfälle eine zuverlässige Lösung. Erst wenn deine Anforderungen aus dem Rahmen fallen, greifst du zu spezialisierten Tools wie usort().

Zusammenfassung und Fazit

Brauchst du maximale Kontrolle über die Sortierung, führt kein Weg an usort() vorbei. Diese Funktion zeigt ihre Stärken immer dann, wenn du mit verschachtelten Arrays, Objekten oder individuellen Kriterien arbeitest. Die Freiheit, deine eigene Vergleichslogik zu formulieren, macht den Unterschied. Allerdings solltest du im Hinterkopf behalten, dass usort() die Schlüssel neu vergibt und das Original-Array direkt verändert.

Setze auf gut durchdachte Vergleichsfunktionen – am besten wiederverwendbar und klar strukturiert. Nutze moderne PHP-Features wie Arrow Functions, um deinen Code lesbar und elegant zu halten. Wer regelmäßig mit komplexen Daten arbeitet, findet in usort() einen echten Allrounder, der in keiner Tool-Sammlung fehlen sollte. Und ganz ehrlich: Wenn du das Prinzip einmal verstanden hast, willst du es nicht mehr missen.