PHP array_key_exists(): prüfen, ob ein Schlüssel existiert

array_key_exists('key', $array) liefert true, wenn das Array diesen Schlüssel hat, und false, wenn nicht. Beachte die Reihenfolge: zuerst der Schlüssel, dann das Array. Es liefert true, selbst wenn der unter dem Schlüssel gespeicherte Wert null ist, und genau das macht isset() nicht.

<?php
$user = ['name' => 'Ada', 'email' => 'ada@example.com', 'phone' => null];

var_dump(array_key_exists('email', $user));
var_dump(array_key_exists('address', $user));
var_dump(array_key_exists('phone', $user));   // key is there, value is null

$list = ['a', 'b', 'c'];
var_dump(array_key_exists(2, $list));         // integer keys too

Um einen Wert statt eines Schlüssels zu prüfen, verwendest du in_array().

array_key_exists vs isset

Beide prüfen auf einen Schlüssel. Sie sind sich nur uneinig, wenn der Wert null ist: isset() behandelt einen null-Wert als „nicht gesetzt“, array_key_exists() meldet, was tatsächlich im Array steht.

<?php
$form = ['name' => 'Ada', 'nickname' => null, 'age' => 0, 'bio' => ''];

foreach (['name', 'nickname', 'age', 'bio', 'missing'] as $key) {
    printf(
        "%-9s isset: %-5s  array_key_exists: %s\n",
        $key,
        var_export(isset($form[$key]), true),
        var_export(array_key_exists($key, $form), true)
    );
}

0 und '' zählen für beide als gesetzt; nur null trennt sie. Welche du willst, hängt davon ab, was null in deinen Daten bedeutet:

• Verwende isset(), wenn null „kein Wert“ bedeutet. Das ist der übliche Fall, es ist ein Sprachkonstrukt (etwas schneller) und akzeptiert verschachtelte Pfade und undefinierte Variablen ohne Warnung.
• Verwende array_key_exists(), wenn null ein echter Wert ist, den du von einem fehlenden Schlüssel unterscheiden musst: ein JSON-Feld, das als null gesendet wurde, eine Datenbankspalte mit NULL, eine Option, die ausdrücklich auf null gesetzt wurde, um sie zu leeren.

Die Seite zu isset behandelt seine anderen Einsätze, etwa mehrere Variablen auf einmal zu prüfen.

null und fehlend in einem JSON-Payload unterscheiden

Ein typischer Fall, in dem nur array_key_exists() die richtige Antwort liefert: eine API, die einen Datensatz aus JSON aktualisiert. Ein Feld, das als null gesendet wird, bedeutet „leeren“, ein weggelassenes Feld bedeutet „nicht anfassen“. isset() sieht beides gleich.

<?php
$record = ['name' => 'Ada', 'phone' => '555-0100', 'city' => 'London'];
$patch  = json_decode('{"phone": null, "city": "Paris"}', true);

foreach (['name', 'phone', 'city'] as $field) {
    if (array_key_exists($field, $patch)) {
        $record[$field] = $patch[$field];   // includes setting null
    }
}

var_dump($record);

Mit isset($patch[$field]) bliebe die Telefonnummer stehen, weil das null wie ein fehlendes Feld aussähe.

key_exists() ist dieselbe Funktion

key_exists() ist ein Alias von array_key_exists(), übrig aus frühem PHP. Gleiche Argumente, gleiches Ergebnis. Bevorzuge den vollen Namen, den Leser erwarten.

<?php
$config = ['debug' => false];

var_dump(key_exists('debug', $config));
var_dump(array_key_exists('debug', $config));
var_dump(key_exists('cache', $config));

Schlüsseltypen: "1" und 1 sind derselbe Schlüssel

Array-Schlüssel sind Ganzzahlen oder Strings, und ein String, der eine einfache Dezimalzahl ist, wird als Ganzzahl gespeichert. Also findet array_key_exists('1', $arr) den Schlüssel 1, und umgekehrt. Ein String wie '01' bleibt ein String und ist ein anderer Schlüssel.

<?php
$byId = [1 => 'Ada', 2 => 'Linus', '07' => 'Grace'];

var_dump(array_key_exists('1', $byId));    // "1" is the int key 1
var_dump(array_key_exists(7, $byId));      // 7 is not "07"
var_dump(array_key_exists('07', $byId));

Verschachtelte und mehrere Schlüssel prüfen

array_key_exists() schaut auf eine Ebene. Für einen verschachtelten Pfad, bei dem null egal ist, prüft isset($a['x']['y']) jede Ebene auf einmal. Für einen Pfad, bei dem es nicht egal ist, geht eine kleine Hilfsfunktion die Ebenen ab. Um zu prüfen, dass mehrere Schlüssel alle vorhanden sind, vergleichst du mit array_diff_key().

<?php
function hasPath(array $data, array $path): bool
{
    foreach ($path as $key) {
        if (!is_array($data) || !array_key_exists($key, $data)) {
            return false;
        }
        $data = $data[$key];
    }
    return true;
}

$order = ['customer' => ['address' => ['city' => 'Lyon', 'zip' => null]]];

var_dump(isset($order['customer']['address']['zip']));          // null: false
var_dump(hasPath($order, ['customer', 'address', 'zip']));       // present: true
var_dump(hasPath($order, ['customer', 'phone']));

$required = ['name', 'email', 'password'];
$input = ['name' => 'Ada', 'email' => 'ada@example.com'];
$missing = array_keys(array_diff_key(array_flip($required), $input));
print_r($missing);

array_flip($required) macht aus der Liste der Namen Schlüssel, damit array_diff_key() sie mit den Schlüsseln der Eingabe vergleichen kann; was übrig bleibt, ist die Liste der fehlenden Felder, fertig für eine Fehlermeldung.

Objekte brauchen property_exists

Ältere PHP-Versionen akzeptierten ein Objekt in array_key_exists(). PHP 8 wirft stattdessen einen TypeError. Bei Objekten prüft property_exists() auf eine deklarierte oder dynamische Eigenschaft (auch eine, die auf null gesetzt ist), und isset($obj->prop) funktioniert wie isset() bei Arrays.

<?php
class User
{
    public ?string $phone = null;
    public string $name = 'Ada';
}

$u = new User();

var_dump(property_exists($u, 'phone'));   // declared, value null
var_dump(isset($u->phone));
var_dump(property_exists($u, 'email'));

$asArray = get_object_vars($u);
var_dump(array_key_exists('name', $asArray));

Die letzten zwei Zeilen zeigen den anderen Weg: get_object_vars() macht aus den zugänglichen Eigenschaften des Objekts ein Array, und dann gelten die Array-Funktionen.