Beim Arbeiten mit Arrays in PHP müssen häufig bestimmte Elemente anhand von Bedingungen herausgefiltert werden. Die Funktion array_filter() durchläuft jedes Element eines Arrays und entscheidet auf Basis einer Callback-Funktion, ob es im Ergebnis enthalten sein soll oder nicht. Ohne Callback entfernt sie automatisch alle sogenannten „falsy“ Werte. Dieses Tutorial erklärt die vollständige Syntax, zeigt verschiedene Filter-Modi und behandelt typische Stolperfallen wie die Beibehaltung der Array-Keys.
Der erste Schritt ist ein Blick auf die Syntax und die drei verfügbaren Filter-Modi, bevor es an praktische Beispiele mit Callbacks und Arrow Functions geht.
Syntax und Parameter
Bevor array_filter() in der Praxis eingesetzt wird, lohnt sich ein genauer Blick auf die Syntax und die verfügbaren Parameter.
<?php
array_filter(array $array, ?callable $callback = null, int $mode = 0): array
Die Funktion erwartet bis zu drei Parameter. Der erste Parameter ist das zu filternde Array. Der zweite Parameter ist eine optionale Callback-Funktion, die für jedes Element aufgerufen wird. Gibt der Callback true zurück, bleibt das Element im Ergebnis erhalten. Gibt er false zurück, wird es aus dem Ergebnis ausgeschlossen. Dabei zählt PHP jeden Wert als true, der nicht explizit false, 0, null oder ein leerer String ist. Der dritte Parameter bestimmt den Filter-Modus und legt fest, welche Werte der Callback erhält. Standardmäßig wird nur der Value übergeben. Mit den Konstanten ARRAY_FILTER_USE_KEY und ARRAY_FILTER_USE_BOTH lassen sich auch die Schlüssel einbeziehen. Die Funktion erstellt immer ein neues Array, das Original bleibt dabei vollständig unverändert.
array_filter ohne Callback (Leere Werte entfernen)
Wird kein Callback angegeben, entfernt array_filter() automatisch alle Elemente, die in PHP als „falsy“ gelten.
<?php
$daten = ['PHP', '', null, 0, false, 'MySQL', [], '0', 42];
$bereinigt = array_filter($daten);
print_r($bereinigt);
/*
Array
(
[0] => PHP
[5] => MySQL
[8] => 42
)
*/
Alle Werte, die PHP bei einer Typumwandlung zu false auswerten würde, werden entfernt. Dazu gehören null, false, die Zahl 0, ein leerer String "", der String "0" und ein leeres Array []. Gerade die Entfernung von 0 und "0" ist eine häufige Stolperfalle. Wer numerische Nullwerte behalten möchte, muss einen eigenen Callback schreiben, der gezielt nur die tatsächlich unerwünschten Werte aussortiert. Ein Callback wie fn($wert) => $wert !== null && $wert !== '' würde beispielsweise nur null und leere Strings entfernen, Nullwerte und false jedoch behalten.
Filtern mit Callback-Funktion
Der eigentliche Nutzen von array_filter() entfaltet sich durch den Einsatz einer Callback-Funktion, die präzise Filterregeln definiert.
Anonyme Funktionen als Callback
Anonyme Funktionen (auch Closures genannt) eignen sich hervorragend als Callback für array_filter(), da sie direkt an Ort und Stelle definiert werden können.
<?php
$zahlen = [3, 18, 7, 25, 12, 4, 30, 9];
$grosseZahlen = array_filter($zahlen, function($wert) {
return $wert >= 10;
});
print_r($grosseZahlen);
/*
Array
(
[1] => 18
[3] => 25
[4] => 12
[6] => 30
)
*/
Die anonyme Funktion erhält jeden Wert des Arrays und gibt true zurück, wenn er größer oder gleich 10 ist. Nur diese Elemente landen im Ergebnis-Array. Soll die Callback-Funktion auf eine externe Variable zugreifen, lässt sich das Schlüsselwort use einsetzen.
<?php
$produkte = ['Laptop', 'Maus', 'Tastatur', 'Monitor', 'USB-Kabel'];
$mindestlaenge = 5;
$ergebnis = array_filter($produkte, function($name) use ($mindestlaenge) {
return strlen($name) >= $mindestlaenge;
});
print_r($ergebnis);
/*
Array
(
[0] => Laptop
[2] => Tastatur
[3] => Monitor
[4] => USB-Kabel
)
*/
Durch use ($mindestlaenge) wird die Variable aus dem umgebenden Scope in die Closure importiert. So lassen sich flexible Filter mit konfigurierbaren Schwellenwerten bauen.
Arrow Functions (ab PHP 7.4)
Seit PHP 7.4 stehen Arrow Functions als kompakte Alternative zur Verfügung. Sie greifen automatisch auf Variablen aus dem äußeren Scope zu, ohne dass use erforderlich ist.
<?php
$preise = [9.99, 24.50, 3.00, 49.95, 14.80];
$ab20 = array_filter($preise, fn($preis) => $preis >= 20);
print_r($ab20);
/*
Array
(
[1] => 24.5
[3] => 49.95
)
*/
Die Syntax fn($preis) => $preis >= 20 ist deutlich kürzer als eine vollständige anonyme Funktion. Arrow Functions eignen sich besonders für einfache, einzeilige Filterbedingungen. Der Rückgabewert wird implizit aus dem Ausdruck nach dem Pfeil abgeleitet, ein explizites return ist nicht nötig.
Filter-Modi
Standardmäßig erhält der Callback nur den Value jedes Elements. Über den dritten Parameter von array_filter() lassen sich jedoch auch die Keys einbeziehen. PHP stellt dafür zwei Konstanten bereit, die das Verhalten des Callbacks gezielt steuern.
Das folgende Diagramm veranschaulicht die drei verfügbaren Modi und welche Werte der Callback jeweils erhält.
flowchart TD
A["array_filter()"] --> B["Modus 0 (Standard)"]
A --> C["ARRAY_FILTER_USE_KEY"]
A --> D["ARRAY_FILTER_USE_BOTH"]
B --> E["Callback erhält: Value"]
C --> F["Callback erhält: Key"]
D --> G["Callback erhält: Value, Key"]
ARRAY_FILTER_USE_KEY
Mit der Konstante ARRAY_FILTER_USE_KEY wird dem Callback nicht der Value, sondern der Key des jeweiligen Elements übergeben.
<?php
$einstellungen = [
'db_host' => 'localhost',
'db_name' => 'shop',
'cache_ttl' => 3600,
'db_password' => 'geheim',
'app_name' => 'MeinShop'
];
$dbEinstellungen = array_filter(
$einstellungen,
fn($key) => str_starts_with($key, 'db_'),
ARRAY_FILTER_USE_KEY
);
print_r($dbEinstellungen);
/*
Array
(
[db_host] => localhost
[db_name] => shop
[db_password] => geheim
)
*/
Hier werden nur die Einträge behalten, deren Schlüssel mit dem Präfix db_ beginnen. Der Callback hat in diesem Modus keinen Zugriff auf den Value, sondern arbeitet ausschließlich mit dem Key. Das ist besonders nützlich, um Konfigurationsarrays nach bestimmten Namensprefixen zu filtern.
ARRAY_FILTER_USE_BOTH
Die Konstante ARRAY_FILTER_USE_BOTH übergibt dem Callback sowohl den Value als auch den Key. Wichtig ist dabei die Reihenfolge der Parameter: Der erste Parameter ist der Value, der zweite der Key.
<?php
$lagerbestand = [
'Laptop' => 15,
'Maus' => 0,
'Tastatur' => 8,
'Monitor' => 0,
'Headset' => 22
];
$verfuegbar = array_filter(
$lagerbestand,
fn($anzahl, $produkt) => $anzahl > 0,
ARRAY_FILTER_USE_BOTH
);
print_r($verfuegbar);
/*
Array
(
[Laptop] => 15
[Tastatur] => 8
[Headset] => 22
)
*/
Die Parameterreihenfolge ($value, $key) ist eine häufige Fehlerquelle. Viele Entwickler erwarten intuitiv ($key, $value), doch array_filter() übergibt den Value stets als ersten und den Key als zweiten Parameter. Wer die Reihenfolge verwechselt, erhält fehlerhafte Filterergebnisse ohne eine Fehlermeldung.
Wichtig: Array-Keys bleiben erhalten
Ein zentrales Verhalten von array_filter() ist die Beibehaltung der Original-Keys. Es findet keine automatische Neu-Indizierung statt.
<?php
$namen = ['Anna', 'Ben', 'Clara', 'David', 'Eva'];
$langNamen = array_filter($namen, fn($name) => strlen($name) > 3);
print_r($langNamen);
/*
Array
(
[0] => Anna
[2] => Clara
[3] => David
)
*/
/* Re-Indexierung mit array_values() */
$neuIndiziert = array_values($langNamen);
print_r($neuIndiziert);
/*
Array
(
[0] => Anna
[1] => Clara
[2] => David
)
*/
Nach dem Filtern fehlen im Ergebnis die Keys 1 und 4. Das ist in den meisten Fällen unproblematisch, kann aber bei der JSON-Ausgabe mit json_encode() zu unerwartetem Verhalten führen. Wenn die Keys nicht lückenlos bei 0 beginnen, erzeugt json_encode() ein JSON-Objekt statt eines JSON-Arrays. Mit array_values() werden die Keys neu durchnummeriert und die Ausgabe wird wieder zu einem sauberen JSON-Array.
<?php
$zahlen = [1, 2, 3, 4, 5];
$gerade = array_filter($zahlen, fn($z) => $z % 2 === 0);
echo json_encode($gerade);
/* {"1":2,"3":4} - JSON-Objekt statt Array */
echo json_encode(array_values($gerade));
/* [2,4] - korrektes JSON-Array */
Dieses Verhalten ist besonders bei API-Endpunkten relevant, die ein JSON-Array als Antwort erwarten. Die Kombination aus array_filter() und array_values() gehört daher zu den Standardmustern in der PHP-Entwicklung.
Praktische Anwendungsfälle
Die Funktion array_filter() kommt in vielen Bereichen der PHP-Entwicklung zum Einsatz. Die folgenden Beispiele zeigen typische Szenarien aus dem Projektalltag.
Nur bestimmte Datentypen behalten
Manchmal enthält ein Array gemischte Datentypen, und nur ein bestimmter Typ soll übrig bleiben.
<?php
$gemischt = [42, 'Hallo', 3.14, true, 'Welt', 7, null, 99];
/* Nur Strings behalten */
$nurStrings = array_filter($gemischt, fn($wert) => is_string($wert));
print_r(array_values($nurStrings));
/*
Array
(
[0] => Hallo
[1] => Welt
)
*/
/* Nur Integer-Werte behalten */
$nurIntegers = array_filter($gemischt, fn($wert) => is_int($wert));
print_r(array_values($nurIntegers));
/*
Array
(
[0] => 42
[1] => 7
[2] => 99
)
*/
Die Typprüfungsfunktionen is_string(), is_int(), is_float() und weitere lassen sich direkt im Callback verwenden. Alternativ kann auch is_numeric() eingesetzt werden, um sowohl Integer als auch Float-Werte zu behalten. So wird ein Array zuverlässig auf einen einzigen Datentyp reduziert, was die anschließende Validierung und Verarbeitung deutlich vereinfacht.
Array nach Bedingung filtern
In der Praxis werden oft Arrays aus assoziativen Sub-Arrays gefiltert, beispielsweise Datensätze aus einer Datenbank oder einer API-Antwort.
<?php
$benutzer = [
['name' => 'Anna', 'alter' => 28, 'aktiv' => true],
['name' => 'Ben', 'alter' => 17, 'aktiv' => true],
['name' => 'Clara', 'alter' => 34, 'aktiv' => false],
['name' => 'David', 'alter' => 22, 'aktiv' => true],
['name' => 'Eva', 'alter' => 15, 'aktiv' => true]
];
/* Nur aktive und volljährige Benutzer */
$gueltig = array_filter($benutzer, function($user) {
return $user['aktiv'] === true && $user['alter'] >= 18;
});
print_r(array_values($gueltig));
/*
Array
(
[0] => Array
(
[name] => Anna
[alter] => 28
[aktiv] => 1
)
[1] => Array
(
[name] => David
[alter] => 22
[aktiv] => 1
)
)
*/
Mehrere Bedingungen lassen sich im Callback beliebig kombinieren. In diesem Beispiel müssen Benutzer sowohl aktiv als auch volljährig sein, um im Ergebnis zu erscheinen. Das Original-Array $benutzer bleibt dabei vollständig unverändert, da array_filter() stets ein neues Array erzeugt.
Fazit
Die Funktion array_filter() ist ein vielseitiges Werkzeug zum gezielten Filtern von Arrays in PHP. Ohne Callback entfernt sie alle „falsy“ Werte, wobei die Entfernung von 0 und "0" beachtet werden muss. Mit einer Callback-Funktion lassen sich beliebig komplexe Filterbedingungen definieren, von einfachen Vergleichen bis hin zu mehrstufigen Validierungen. Die drei Filter-Modi steuern, ob der Callback den Value, den Key oder beides erhält. Besonders wichtig ist das Wissen um die erhaltenen Array-Keys: Für eine saubere JSON-Ausgabe oder eine lückenlose Nummerierung sollte array_values() nach dem Filtern eingesetzt werden. Die Parameterreihenfolge bei ARRAY_FILTER_USE_BOTH ist ($value, $key) und nicht umgekehrt. Zusammen mit Arrow Functions seit PHP 7.4 wird array_filter() zu einem kompakten und gut lesbaren Baustein der funktionalen Array-Verarbeitung in PHP.
