PHP array_key_exists(): verificare se una chiave esiste

array_key_exists('key', $array) restituisce true se l'array ha quella chiave e false se non ce l'ha. Nota l'ordine: prima la chiave, poi l'array. Restituisce true anche quando il valore salvato sotto la chiave è null, l'unica cosa che isset() non fa.

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

Per verificare un valore invece di una chiave, usa in_array().

array_key_exists vs isset

Entrambe verificano una chiave. Non sono d'accordo solo quando il valore è null: isset() tratta un valore null come "non impostato", array_key_exists() riporta ciò che c'è davvero nell'array.

<?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 e '' contano come impostati per entrambe; solo null le divide. Quale ti serve dipende da cosa significa null nei tuoi dati:

• Usa isset() quando null significa "nessun valore". È il caso comune, è un costrutto del linguaggio (un po' più veloce) e accetta percorsi annidati e variabili non definite senza warning.
• Usa array_key_exists() quando null è un valore reale che devi distinguere da una chiave mancante: un campo JSON inviato come null, una colonna del database che è NULL, un'opzione impostata esplicitamente a null per azzerarla.

La pagina su isset tratta i suoi altri usi, compreso il controllo di più variabili insieme.

Distinguere null da mancante in un payload JSON

Un caso tipico in cui solo array_key_exists() dà la risposta giusta: un'API che aggiorna un record da un JSON. Un campo inviato come null significa "azzeralo", un campo omesso significa "non toccarlo". isset() li vede come la stessa cosa.

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

Con isset($patch[$field]) il numero di telefono resterebbe, perché il null sembrerebbe un campo mancante.

key_exists() è la stessa funzione

key_exists() è un alias di array_key_exists(), rimasto dalle prime versioni di PHP. Stessi argomenti, stesso risultato. Preferisci il nome completo, che è quello che chi legge si aspetta.

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

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

Tipi di chiave: "1" e 1 sono la stessa chiave

Le chiavi degli array sono interi o stringhe, e una stringa che è un semplice intero decimale viene memorizzata come intero. Quindi array_key_exists('1', $arr) trova la chiave 1, e viceversa. Una stringa come '01' resta una stringa ed è una chiave diversa.

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

Verificare chiavi annidate e più chiavi

array_key_exists() guarda un solo livello. Per un percorso annidato in cui null non conta, isset($a['x']['y']) verifica ogni livello in una volta. Per un percorso in cui conta, una piccola funzione di supporto percorre i livelli. Per verificare che più chiavi siano tutte presenti, confronta con 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) trasforma la lista di nomi in chiavi così array_diff_key() può confrontarle con le chiavi dell'input; ciò che avanza è la lista dei campi mancanti, pronta per un messaggio di errore.

Gli oggetti richiedono property_exists

Le vecchie versioni di PHP accettavano un oggetto in array_key_exists(). PHP 8 lancia invece un TypeError. Per gli oggetti, property_exists() verifica una proprietà dichiarata o dinamica (anche se impostata a null), e isset($obj->prop) funziona come isset() sugli array.

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

Le ultime due righe mostrano l'altra strada: get_object_vars() trasforma le proprietà accessibili dell'oggetto in un array, e a quel punto si applicano le funzioni per array.