PHP array_key_exists(): comprobar si existe una clave

array_key_exists('key', $array) devuelve true si el array tiene esa clave y false si no. Fíjate en el orden: primero la clave, después el array. Devuelve true incluso cuando el valor guardado bajo la clave es null, que es justo lo que isset() no hace.

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

Para comprobar un valor en lugar de una clave, usa in_array().

array_key_exists vs isset

Las dos comprueban una clave. Solo discrepan cuando el valor es null: isset() trata un valor null como "no definido", y array_key_exists() informa de lo que hay realmente en el 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 y '' cuentan como definidos para las dos; solo null las separa. Cuál quieres depende de lo que signifique null en tus datos:

• Usa isset() cuando null significa "sin valor". Es el caso habitual, es una construcción del lenguaje (algo más rápida) y acepta rutas anidadas y variables no definidas sin ningún warning.
• Usa array_key_exists() cuando null es un valor real que debes distinguir de una clave ausente: un campo JSON enviado como null, una columna de base de datos que es NULL, una opción puesta a null a propósito para borrarla.

La página de isset explica sus otros usos, como comprobar varias variables a la vez.

Distinguir null de ausente en un payload JSON

Un caso típico en el que solo array_key_exists() da la respuesta correcta: una API que actualiza un registro a partir de JSON. Un campo enviado como null significa "bórralo", y un campo omitido significa "no lo toques". isset() ve los dos casos igual.

<?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]) el número de teléfono se quedaría, porque el null parecería un campo ausente.

key_exists() es la misma función

key_exists() es un alias de array_key_exists(), que se conserva desde las primeras versiones de PHP. Mismos argumentos, mismo resultado. Prefiere el nombre completo, que es lo que esperan ver quienes leen el código.

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

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

Tipos de clave: "1" y 1 son la misma clave

Las claves de un array son enteros o cadenas, y una cadena que es un entero decimal simple se guarda como entero. Así, array_key_exists('1', $arr) encuentra la clave 1, y al revés. Una cadena como '01' se queda como cadena y es una clave distinta.

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

Comprobar claves anidadas y varias claves

array_key_exists() mira un solo nivel. Para una ruta anidada en la que null no importa, isset($a['x']['y']) comprueba todos los niveles de una vez. Para una ruta en la que sí importa, una pequeña función auxiliar recorre los niveles. Para comprobar que están presentes varias claves, compara 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) convierte la lista de nombres en claves para que array_diff_key() pueda compararlas con las claves de la entrada; lo que queda es la lista de campos que faltan, lista para un mensaje de error.

Los objetos necesitan property_exists

Las versiones antiguas de PHP aceptaban un objeto en array_key_exists(). PHP 8 lanza un TypeError en su lugar. Para objetos, property_exists() comprueba una propiedad declarada o dinámica (aunque valga null), e isset($obj->prop) funciona como isset() con 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));

Las dos últimas líneas muestran la otra vía: get_object_vars() convierte las propiedades accesibles del objeto en un array, y entonces se aplican las funciones de arrays.