PHP 8.4 bringt vier neue Array-Funktionen mit, die das Durchsuchen von Arrays nach bestimmten Bedingungen deutlich vereinfachen: array_find(), array_find_key(), array_any() und array_all(). Diese Funktionen schließen eine Lücke, die Entwickler bisher mit array_filter() oder manuellen Schleifen überbrücken mussten. Alle vier Funktionen arbeiten mit einer Callback Function, die für jedes Element im Array aufgerufen wird. Der Callback erhält dabei den Value und den Key als Parameter. In diesem Tutorial werden die vier neuen Funktionen anhand praktischer Beispiele vorgestellt, ihre Unterschiede zu array_filter() erläutert und ein Polyfill für ältere PHP-Versionen gezeigt.
Den Anfang macht array_find(), das den ersten passenden Wert liefert. Danach folgen array_find_key(), array_any() und array_all() mit ihren jeweiligen Einsatzbereichen.
array_find: Den ersten Treffer zurückgeben
Die Funktion array_find() durchsucht ein Array und gibt das erste Element zurück, für das der Callback true liefert. Wird kein passendes Element gefunden, gibt die Funktion null zurück. Die Suche stoppt, sobald der erste Treffer vorliegt. Das macht array_find() besonders effizient bei großen Arrays, da nicht alle Elemente geprüft werden müssen.
<?php
$produkte = [
['name' => 'Laptop', 'preis' => 899],
['name' => 'Maus', 'preis' => 29],
['name' => 'Tastatur', 'preis' => 59],
['name' => 'Monitor', 'preis' => 349],
];
$teuer = array_find($produkte, fn(array $p) => $p['preis'] > 300);
echo $teuer['name'];
/* Ausgabe: Laptop */
In diesem Beispiel wird das erste Produkt mit einem Preis über 300 gesucht. Der Callback erhält jedes Element als ersten Parameter und gibt true zurück, wenn die Bedingung erfüllt ist. Da Laptop das erste Element ist, das die Bedingung erfüllt, wird es sofort zurückgegeben. Die restlichen Elemente werden nicht mehr geprüft.
Eine wichtige Stolperfalle: Wenn kein Element die Bedingung erfüllt, gibt array_find() den Wert null zurück. Das kann bei Arrays, die selbst null oder andere falsy Werte enthalten, zu Verwechslungen führen. In solchen Fällen ist array_find_key() die sicherere Wahl, da Keys in der Regel eindeutig sind.
<?php
$zahlen = [1, 3, 5, 7, 9];
$gerade = array_find($zahlen, fn(int $n) => $n % 2 === 0);
var_dump($gerade);
/* Ausgabe: NULL */
array_find_key: Den Key des ersten Treffers
Die Funktion array_find_key() arbeitet nach demselben Prinzip wie array_find(), gibt aber nicht den Wert, sondern den Key des ersten passenden Elements zurück. Auch hier wird null zurückgegeben, wenn kein Treffer vorliegt.
<?php
$mitarbeiter = [
'entwicklung' => ['name' => 'Anna', 'gehalt' => 75000],
'vertrieb' => ['name' => 'Ben', 'gehalt' => 65000],
'marketing' => ['name' => 'Clara', 'gehalt' => 80000],
];
$key = array_find_key(
$mitarbeiter,
fn(array $m) => $m['gehalt'] > 70000
);
echo $key;
/* Ausgabe: entwicklung */
Der Callback erhält den Value als ersten und den Key als zweiten Parameter. Das gilt für alle vier neuen Funktionen. Die Reihenfolge ist also fn($value, $key). Diese Parameterreihenfolge folgt dem etablierten Muster von array_map() und array_filter() und sorgt dafür, dass der Key als optionaler zweiter Parameter weggelassen werden kann, wenn er nicht benötigt wird.
array_any: Gibt es mindestens ein passendes Element?
Mit array_any() lässt sich prüfen, ob mindestens ein Element im Array die angegebene Bedingung erfüllt. Die Funktion gibt true zurück, sobald der Callback für ein Element true liefert, und false, wenn kein Element passt. Auch hier wird die Iteration beim ersten Treffer abgebrochen.
<?php
$bestellungen = [
['id' => 1, 'status' => 'versendet'],
['id' => 2, 'status' => 'offen'],
['id' => 3, 'status' => 'versendet'],
];
$hatOffene = array_any(
$bestellungen,
fn(array $b) => $b['status'] === 'offen'
);
var_dump($hatOffene);
/* Ausgabe: bool(true) */
Der Rückgabewert ist ein Boolean, kein Array-Element. Das ist ein wesentlicher Unterschied zu array_find(). Während array_find() das Element selbst liefert, beantwortet array_any() nur die Frage, ob ein passendes Element existiert. Für einfache Prüfungen in Bedingungen ist das oft ausreichend und sprechender als ein Vergleich mit null.
array_all: Erfüllen alle Elemente die Bedingung?
Die Funktion array_all() ist das Gegenstück zu array_any(). Sie gibt true zurück, wenn alle Elemente im Array die Bedingung erfüllen. Sobald ein Element den Callback mit false beantwortet, wird die Iteration abgebrochen und false zurückgegeben.
<?php
$produkte = [
['name' => 'Laptop', 'lagerbestand' => 5],
['name' => 'Maus', 'lagerbestand' => 12],
['name' => 'Tastatur', 'lagerbestand' => 3],
];
$alleVerfuegbar = array_all(
$produkte,
fn(array $p) => $p['lagerbestand'] > 0
);
var_dump($alleVerfuegbar);
/* Ausgabe: bool(true) */
$alleReichlich = array_all(
$produkte,
fn(array $p) => $p['lagerbestand'] > 10
);
var_dump($alleReichlich);
/* Ausgabe: bool(false) */
Typische Anwendungsfälle für array_all() sind Validierungen. Beispielsweise lässt sich damit prüfen, ob alle Pflichtfelder eines Formulars ausgefüllt sind oder ob alle Produkte in einem Warenkorb lieferbar sind.
Das folgende Diagramm zeigt die vier neuen Funktionen und ihre Rückgabewerte im Überblick.
flowchart TD
A["Array mit Callback durchsuchen"] --> B["array_find()"]
A --> C["array_find_key()"]
A --> D["array_any()"]
A --> E["array_all()"]
B --> F["Erster passender Value oder null"]
C --> G["Key des ersten Treffers oder null"]
D --> H["true wenn mindestens einer passt"]
E --> I["true wenn alle passen"]
Vergleich mit array_filter
Vor PHP 8.4 war array_filter() die übliche Wahl, um Elemente nach einer Bedingung zu suchen. Der entscheidende Unterschied: array_filter() durchläuft immer das gesamte Array und gibt ein neues Array mit allen passenden Elementen zurück. Wenn nur das erste passende Element benötigt wird, ist das unnötiger Aufwand.
<?php
$zahlen = [3, 7, 12, 5, 20, 8];
/* Vor PHP 8.4: array_filter und reset */
$gefilter = array_filter($zahlen, fn(int $n) => $n > 10);
$erster = reset($gefilter) ?: null;
echo $erster;
/* Ausgabe: 12 */
/* Ab PHP 8.4: array_find */
$erster = array_find($zahlen, fn(int $n) => $n > 10);
echo $erster;
/* Ausgabe: 12 */
Die Variante mit array_find() ist nicht nur kürzer, sondern auch performanter. Bei einem Array mit 10.000 Elementen, in dem der erste Treffer an Position 5 steht, prüft array_find() nur 5 Elemente. array_filter() hingegen durchläuft alle 10.000 Einträge und erstellt zusätzlich ein neues Array im Speicher. Dasselbe gilt für array_any() im Vergleich zu !empty(array_filter(...)) und für array_all() im Vergleich zu count(array_filter(...)) === count($array).
Polyfill für ältere PHP-Versionen
Wer die neuen Funktionen bereits vor dem Umstieg auf PHP 8.4 nutzen möchte, kann einen Polyfill einsetzen. Die folgende Implementierung bildet das Verhalten der vier Funktionen nach.
<?php
if (!function_exists('array_find')) {
function array_find(array $array, callable $callback): mixed
{
foreach ($array as $key => $value) {
if ($callback($value, $key)) {
return $value;
}
}
return null;
}
}
if (!function_exists('array_find_key')) {
function array_find_key(array $array, callable $callback): mixed
{
foreach ($array as $key => $value) {
if ($callback($value, $key)) {
return $key;
}
}
return null;
}
}
if (!function_exists('array_any')) {
function array_any(array $array, callable $callback): bool
{
foreach ($array as $key => $value) {
if ($callback($value, $key)) {
return true;
}
}
return false;
}
}
if (!function_exists('array_all')) {
function array_all(array $array, callable $callback): bool
{
foreach ($array as $key => $value) {
if (!$callback($value, $key)) {
return false;
}
}
return true;
}
}
Die Prüfung mit function_exists() stellt sicher, dass der Polyfill nur geladen wird, wenn die native Funktion nicht verfügbar ist. Beim späteren Umstieg auf PHP 8.4 kann der Polyfill entfernt werden, ohne den restlichen Code anpassen zu müssen. Als Alternative steht auf GitHub das Paket php-polyfills/array-find zur Verfügung, das sich per Composer installieren lässt.
Fazit
Mit array_find(), array_find_key(), array_any() und array_all() erhält PHP 8.4 vier Funktionen, die das Arbeiten mit Arrays spürbar verbessern. array_find() gibt das erste Element zurück, das eine Bedingung erfüllt, und stoppt die Suche beim ersten Treffer. array_find_key() liefert den Key statt den Value. array_any() und array_all() beantworten als Boolean, ob mindestens ein oder alle Elemente die Bedingung erfüllen. Gegenüber array_filter() sind diese Funktionen effizienter, da sie nicht das gesamte Array durchlaufen und kein neues Array erstellen. Der Callback erhält bei allen vier Funktionen den Value als ersten und den Key als zweiten Parameter. Für Projekte, die noch nicht auf PHP 8.4 laufen, bietet ein einfacher Polyfill eine zukunftssichere Lösung. Die vier neuen Array-Funktionen schließen eine lang bestehende Lücke im PHP-Funktionsumfang und machen den Code lesbarer, kürzer und performanter.
