PHP array_key_exists(): verificar se uma chave existe

array_key_exists('key', $array) retorna true se o array tem essa chave e false se não tem. Repare na ordem: a chave vem primeiro, o array depois. Ele retorna true mesmo quando o valor guardado na chave é null, que é a única coisa que o isset() não faz.

<?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 verificar um valor em vez de uma chave, use in_array().

array_key_exists ou isset

Os dois verificam uma chave. Eles só discordam quando o valor é null: o isset() trata um valor null como "não definido", o array_key_exists() informa o que realmente está no 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 '' contam como definidos para os dois; só o null os separa. Qual você quer depende do que null significa nos seus dados:

• Use isset() quando null significa "sem valor". É o caso comum, é uma construção da linguagem (um pouco mais rápida) e aceita caminhos aninhados e variáveis indefinidas sem aviso.
• Use array_key_exists() quando null é um valor real que você precisa distinguir de uma chave ausente: um campo JSON enviado como null, uma coluna do banco que é NULL, uma opção definida explicitamente como null para limpá-la.

A página sobre isset cobre os outros usos dele, incluindo verificar várias variáveis de uma vez.

Distinguir null de ausente num payload JSON

Um caso típico em que só o array_key_exists() dá a resposta certa: uma API que atualiza um registro a partir de JSON. Um campo enviado como null significa "limpe isto", um campo omitido significa "não mexa". O isset() vê os dois como a mesma coisa.

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

Com isset($patch[$field]), o número de telefone continuaria, porque o null pareceria um campo ausente.

key_exists() é a mesma função

key_exists() é um alias de array_key_exists(), mantido desde as primeiras versões do PHP. Mesmos argumentos, mesmo resultado. Prefira o nome completo, que é o que os leitores esperam ver.

<?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 chave: "1" e 1 são a mesma chave

Chaves de array são inteiros ou strings, e uma string que é um inteiro decimal simples é guardada como inteiro. Então array_key_exists('1', $arr) encontra a chave 1, e vice-versa. Uma string como '01' continua string e é outra chave.

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

Verificar chaves aninhadas e várias chaves

O array_key_exists() olha um nível. Para um caminho aninhado em que null não importa, isset($a['x']['y']) verifica todos os níveis de uma vez. Para um caminho em que importa, uma pequena função auxiliar percorre os níveis. Para verificar se várias chaves estão todas presentes, compare com 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) transforma a lista de nomes em chaves para que o array_diff_key() possa compará-las com as chaves da entrada; o que sobra é a lista de campos ausentes, pronta para uma mensagem de erro.

Objetos precisam de property_exists

Versões antigas do PHP aceitavam um objeto no array_key_exists(). O PHP 8 lança um TypeError. Para objetos, property_exists() verifica uma propriedade declarada ou dinâmica (mesmo uma definida como null), e isset($obj->prop) funciona como o isset() em 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));

As duas últimas linhas mostram o outro caminho: get_object_vars() transforma as propriedades acessíveis do objeto num array, e então as funções de array se aplicam.