PHP array_key_exists(): Check if an Array Key Exists

array_key_exists('key', $array) returns true if the array has that key and false if it does not. Note the order: the key comes first, the array second. It returns true even when the value stored under the key is null, which is the one thing isset() does not do.

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

To check a value rather than a key, use in_array().

array_key_exists vs isset

Both check for a key. They disagree only when the value is null: isset() treats a null value as "not set", array_key_exists() reports what is actually in the 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 and '' count as set for both; only null splits them. Which one you want depends on what null means in your data:

• Use isset() when null means "no value". It is the common case, it is a language construct (slightly faster), and it accepts nested paths and undefined variables without a warning.
• Use array_key_exists() when null is a real value you must tell apart from a missing key: a JSON field sent as null, a database column that is NULL, an option explicitly set to null to clear it.

The isset page covers its other uses, including checking several variables at once.

Tell null apart from missing in a JSON payload

A typical case where only array_key_exists() gives the right answer: an API that updates a record from JSON. A field sent as null means "clear it", a field left out means "do not touch it". isset() sees both as the same.

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

With isset($patch[$field]) the phone number would stay, because the null would look like a missing field.

key_exists() is the same function

key_exists() is an alias of array_key_exists(), kept from early PHP. Same arguments, same result. Prefer the full name, which is what readers expect to see.

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

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

Key types: "1" and 1 are the same key

Array keys are integers or strings, and a string that is a plain decimal integer is stored as an integer. So array_key_exists('1', $arr) finds the key 1, and the other way round. A string like '01' stays a string and is a different key.

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

Check nested keys and several keys

array_key_exists() looks at one level. For a nested path where null does not matter, isset($a['x']['y']) checks every level at once. For a path where it does, a short helper walks the levels. To check that several keys are all present, compare against 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) turns the list of names into keys so array_diff_key() can compare them with the input's keys; what is left over is the list of missing fields, ready for an error message.

Objects need property_exists

Older PHP accepted an object in array_key_exists(). PHP 8 throws a TypeError instead. For objects, property_exists() checks for a declared or dynamic property (even one set to null), and isset($obj->prop) works like isset() on 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));

The last two lines show the other route: get_object_vars() turns the object's accessible properties into an array, and then the array functions apply.