PHP array_key_exists() : vérifier si une clé existe

array_key_exists('key', $array) renvoie true si le tableau a cette clé et false sinon. Attention à l'ordre : la clé d'abord, le tableau ensuite. Elle renvoie true même quand la valeur rangée sous la clé vaut null, la seule chose que isset() ne fait pas.

<?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

Pour vérifier une valeur plutôt qu'une clé, utilisez in_array().

array_key_exists ou isset

Les deux vérifient une clé. Elles ne divergent que quand la valeur vaut null : isset() traite une valeur null comme « non définie », array_key_exists() indique ce qui se trouve vraiment dans le tableau.

<?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 et '' comptent comme définies pour les deux ; seul null les sépare. Le bon choix dépend de ce que signifie null dans vos données :

• Utilisez isset() quand null signifie « pas de valeur ». C'est le cas courant, c'est une construction du langage (un peu plus rapide), et elle accepte les chemins imbriqués et les variables non définies sans warning.
• Utilisez array_key_exists() quand null est une vraie valeur à distinguer d'une clé absente : un champ JSON envoyé à null, une colonne de base de données à NULL, une option explicitement mise à null pour l'effacer.

La page isset couvre ses autres usages, y compris la vérification de plusieurs variables à la fois.

Distinguer null d'une absence dans du JSON

Un cas typique où seule array_key_exists() donne la bonne réponse : une API qui met à jour un enregistrement à partir de JSON. Un champ envoyé à null signifie « l'effacer », un champ absent signifie « ne pas y toucher ». isset() voit les deux comme identiques.

<?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);

Avec isset($patch[$field]), le numéro de téléphone resterait, car le null ressemblerait à un champ absent.

key_exists() est la même fonction

key_exists() est un alias de array_key_exists(), conservé depuis les débuts de PHP. Mêmes arguments, même résultat. Préférez le nom complet, celui que les lecteurs s'attendent à voir.

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

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

Types de clés : "1" et 1 sont la même clé

Les clés de tableau sont des entiers ou des chaînes, et une chaîne qui est un simple entier décimal est stockée comme un entier. Donc array_key_exists('1', $arr) trouve la clé 1, et inversement. Une chaîne comme '01' reste une chaîne et c'est une clé différente.

<?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));

Vérifier des clés imbriquées et plusieurs clés

array_key_exists() regarde un seul niveau. Pour un chemin imbriqué où null ne compte pas, isset($a['x']['y']) vérifie tous les niveaux d'un coup. Pour un chemin où il compte, une petite fonction parcourt les niveaux. Pour vérifier que plusieurs clés sont toutes présentes, comparez avec 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) transforme la liste de noms en clés pour que array_diff_key() puisse les comparer aux clés de l'entrée ; ce qui reste est la liste des champs manquants, prête pour un message d'erreur.

Les objets demandent property_exists

Les anciennes versions de PHP acceptaient un objet dans array_key_exists(). PHP 8 lève une TypeError à la place. Pour les objets, property_exists() vérifie une propriété déclarée ou dynamique (même mise à null), et isset($obj->prop) fonctionne comme isset() sur les tableaux.

<?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));

Les deux dernières lignes montrent l'autre voie : get_object_vars() transforme les propriétés accessibles de l'objet en tableau, et les fonctions de tableau s'appliquent ensuite.