Beim Arbeiten mit Arrays muss man häufig wissen, ob ein bestimmter Schlüssel vorhanden ist, bevor man auf den zugehörigen Wert zugreift. Genau dafür gibt es in PHP die Funktion array_key_exists(). Sie prüft, ob ein Schlüssel in einem Array existiert, und gibt true oder false zurück. Besonders wichtig wird diese Funktion, wenn Array-Werte bewusst auf null gesetzt sein können, denn in diesem Fall versagt die oft verwendete Alternative isset().
Syntax von array_key_exists()
Die Funktion erwartet zwei Parameter: den gesuchten Schlüssel und das Array, in dem gesucht werden soll.
<?php
array_key_exists(mixed $key, array $array): bool
?>
Der erste Parameter $key ist der Schlüssel, der überprüft werden soll. Er kann ein int oder ein string sein. Der zweite Parameter $array ist das zu durchsuchende Array. Die Funktion gibt true zurück, wenn der Schlüssel vorhanden ist, andernfalls false.
Grundlagen: Schlüssel in einem Array prüfen
Die einfachste Anwendung von array_key_exists() ist die Überprüfung, ob ein bestimmter Schlüssel in einem Array enthalten ist. Das funktioniert sowohl mit numerischen als auch mit assoziativen Schlüsseln.
Numerische Schlüssel
Bei einem numerisch indizierten Array prüft man, ob ein bestimmter Index vorhanden ist:
<?php
$array = [1 => 'Wert1', 2 => 'Wert2', 5 => 'Wert5'];
if (array_key_exists(1, $array)) {
echo 'Schlüssel 1 existiert';
}
if (!array_key_exists(3, $array)) {
echo 'Schlüssel 3 existiert nicht';
}
?>
Hier startet das Array nicht bei 0 und hat Lücken in den Indizes. Mit array_key_exists() kann man gezielt prüfen, welche Indizes tatsächlich belegt sind, bevor man darauf zugreift.
Assoziative Schlüssel
Bei assoziativen Arrays sind die Schlüssel Strings. Hier zeigt array_key_exists() seinen typischen Einsatz:
<?php
$benutzer = [
'name' => 'Max Mustermann',
'email' => 'max@example.com',
'alter' => 30
];
if (array_key_exists('email', $benutzer)) {
echo 'E-Mail: ' . $benutzer['email'];
}
if (!array_key_exists('telefon', $benutzer)) {
echo 'Kein Telefon hinterlegt';
}
?>
In der Praxis arbeitet man fast immer mit assoziativen Arrays, etwa wenn man Benutzerdaten, Konfigurationswerte oder Formulareingaben verarbeitet.
Der entscheidende Unterschied: array_key_exists() vs. isset()
Auf den ersten Blick scheinen array_key_exists() und isset() das Gleiche zu tun. Beide prüfen, ob ein Schlüssel in einem Array vorhanden ist. Der entscheidende Unterschied zeigt sich bei null-Werten:
<?php
$daten = [
'name' => 'Max',
'alter' => null,
'beruf' => '',
'punkte' => 0,
'aktiv' => false
];
/* Schlüssel existiert, Wert ist null */
var_dump(array_key_exists('alter', $daten)); // true
var_dump(isset($daten['alter'])); // false!
/* Leerer String, 0 und false */
var_dump(isset($daten['beruf'])); // true
var_dump(isset($daten['punkte'])); // true
var_dump(isset($daten['aktiv'])); // true
/* Nicht vorhandener Schlüssel */
var_dump(array_key_exists('xyz', $daten)); // false
var_dump(isset($daten['xyz'])); // false
?>
isset() gibt false zurück, sobald der Wert null ist. Man kann damit also nicht unterscheiden, ob ein Schlüssel fehlt oder ob er bewusst auf null gesetzt wurde. array_key_exists() prüft dagegen ausschließlich, ob der Schlüssel vorhanden ist, unabhängig vom gespeicherten Wert.
Für die meisten Alltagsfälle reicht isset() völlig aus und ist dabei auch etwas schneller, da es ein Sprachkonstrukt und keine Funktion ist. array_key_exists() ist aber die sicherere Wahl, wenn null ein gültiger Wert in den Daten sein kann.
Vergleich: array_key_exists() vs. isset() vs. in_array()
Bei der Arbeit mit Arrays tauchen drei Funktionen immer wieder auf. Die folgende Übersicht zeigt, wann welche Funktion die richtige Wahl ist:
| Funktion | Prüft | null-Verhalten | Typischer Einsatz |
|---|
array_key_exists() | Ob ein Schlüssel existiert | Gibt true zurück, auch bei null | Konfigurationen, optionale Parameter |
isset() | Ob ein Schlüssel existiert und nicht null ist | Gibt false bei null | Allgemeine Existenzprüfung |
in_array() | Ob ein Wert im Array enthalten ist | Kann null als Wert finden | Wert in einer Liste suchen |
Kurz zusammengefasst: array_key_exists() und isset() prüfen Schlüssel, in_array() prüft Werte. Wer den Schlüssel zu einem bestimmten Wert finden möchte, verwendet die Funktion array_search().
Praxisbeispiel: Optionen und Konfigurationen validieren
Ein häufiger Anwendungsfall in der Praxis: Eine Funktion erhält ein Options-Array und muss prüfen, welche Optionen gesetzt wurden. Gerade hier ist array_key_exists() wichtig, weil Optionswerte auch null, false oder 0 sein können.
<?php
function datenbankVerbindung(array $optionen): void
{
$standard = [
'host' => 'localhost',
'port' => 3306,
'charset' => 'utf8mb4',
'timeout' => null
];
foreach ($standard as $key => $default) {
if (array_key_exists($key, $optionen)) {
$wert = $optionen[$key];
} else {
$wert = $default;
}
echo $key . ': ' . var_export($wert, true) . PHP_EOL;
}
}
datenbankVerbindung([
'host' => '192.168.1.100',
'timeout' => null
]);
/* Ausgabe:
host: '192.168.1.100'
port: 3306
charset: 'utf8mb4'
timeout: NULL
*/
?>
In diesem Beispiel wird timeout bewusst auf null gesetzt, um den Standard-Timeout des Systems zu verwenden. Mit isset() würde man diesen Wert übersehen, weil es bei null immer false liefert. array_key_exists() erkennt korrekt, dass die Option vom Aufrufer gesetzt wurde.
Verschachtelte Arrays prüfen
Bei mehrdimensionalen Arrays reicht ein einzelner Aufruf von array_key_exists() nicht aus. Man muss Ebene für Ebene prüfen, um Fehler zu vermeiden:
<?php
$config = [
'datenbank' => [
'host' => 'localhost',
'port' => 3306
],
'cache' => [
'aktiv' => true,
'dauer' => 3600
]
];
/* Ebene für Ebene prüfen */
if (array_key_exists('datenbank', $config)
&& is_array($config['datenbank'])
&& array_key_exists('host', $config['datenbank'])
) {
echo $config['datenbank']['host'];
}
/* Null-Coalescing als kürzere Alternative */
$host = $config['datenbank']['host'] ?? 'localhost';
$port = $config['datenbank']['port'] ?? 3306;
?>
Der Null-Coalescing-Operator (??) ist in vielen Fällen die kürzere Alternative. Er gibt den linken Wert zurück, wenn dieser existiert und nicht null ist, ansonsten den rechten Fallback-Wert. Für eine reine Existenzprüfung bei möglichen null-Werten bleibt array_key_exists() die zuverlässigere Wahl.
Wer häufig mit Arrays in PHP arbeitet, kann sich eine Hilfsfunktion schreiben, die verschachtelte Schlüssel in einem einzigen Aufruf prüft:
<?php
function arrayKeyExistsNested(
array $keys,
array $array
): bool {
foreach ($keys as $key) {
if (!is_array($array)
|| !array_key_exists($key, $array)
) {
return false;
}
$array = $array[$key];
}
return true;
}
$existiert = arrayKeyExistsNested(
['datenbank', 'host'],
$config
); // true
$existiert = arrayKeyExistsNested(
['datenbank', 'debug'],
$config
); // false
?>
Verwandte Funktionen
PHP bietet eine ganze Reihe von Funktionen, um Arrays zu durchsuchen und zu analysieren. Je nach Anwendungsfall ist eine andere Funktion die bessere Wahl:
isset(): Schnellere Alternative, wenn null-Werte keine Rolle spielenin_array(): Prüft, ob ein bestimmter Wert (nicht Schlüssel) im Array enthalten istarray_search(): Sucht einen Wert und gibt den zugehörigen Schlüssel zurückarray_keys(): Gibt alle Schlüssel eines Arrays als neues Array zurück
Häufige Fragen zu array_key_exists()
Die wichtigsten Fragen rund um array_key_exists() im Überblick:
Wann sollte ich array_key_exists() statt isset() verwenden? Immer dann, wenn Array-Werte bewusst null sein können. isset() gibt bei null-Werten false zurück, obwohl der Schlüssel existiert. In Konfigurationsarrays oder bei optionalen Parametern ist das ein häufiger Fall.
Ist array_key_exists() langsamer als isset()? isset() ist geringfügig schneller, weil es ein Sprachkonstrukt ist und kein Funktionsaufruf. In der Praxis ist der Unterschied bei einzelnen Aufrufen nicht messbar. Nur in Schleifen mit hunderttausenden Durchläufen kann es einen spürbaren Unterschied geben.
Funktioniert array_key_exists() auch mit mehrdimensionalen Arrays? Nicht direkt. Die Funktion prüft nur die erste Ebene des Arrays. Für verschachtelte Schlüssel muss man entweder Ebene für Ebene prüfen oder eine eigene Hilfsfunktion verwenden. Ein Beispiel dafür findet sich im Abschnitt weiter oben.
Was passiert bei einem nicht existierenden Schlüssel? Die Funktion gibt einfach false zurück, ohne eine Warnung oder einen Fehler auszulösen. Das macht sie sicher in der Anwendung, auch wenn man nicht genau weiß, welche Schlüssel ein Array enthält.
Kann ich array_key_exists() mit dem Null-Coalescing-Operator ersetzen? Teilweise. Der ??-Operator ist eine bequeme Alternative, wenn man einen Fallback-Wert setzen möchte: $wert = $array['key'] ?? 'standard'. Er unterscheidet aber nicht zwischen einem fehlenden Schlüssel und einem null-Wert. Wenn diese Unterscheidung wichtig ist, braucht man weiterhin array_key_exists().
