array_key_exists() w PHP: czy klucz istnieje w tablicy

array_key_exists('key', $array) zwraca true, jeśli tablica ma ten klucz, i false, jeśli go nie ma. Zwróć uwagę na kolejność: najpierw klucz, potem tablica. Zwraca true nawet wtedy, gdy wartością pod kluczem jest null, czego jako jedynego nie robi isset().

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

Aby sprawdzić wartość, a nie klucz, użyj in_array().

array_key_exists vs isset

Obie sprawdzają klucz. Różnią się tylko wtedy, gdy wartością jest null: isset() traktuje wartość null jako „nieustawioną”, a array_key_exists() zgłasza to, co faktycznie jest w tablicy.

<?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 i '' obie uznają za ustawione; rozdziela je tylko null. To, której potrzebujesz, zależy od tego, co null oznacza w twoich danych:

• Używaj isset(), gdy null oznacza „brak wartości”. To częsty przypadek, jest to konstrukcja języka (odrobinę szybsza) i przyjmuje zagnieżdżone ścieżki oraz niezdefiniowane zmienne bez ostrzeżenia.
• Używaj array_key_exists(), gdy null jest prawdziwą wartością, którą musisz odróżnić od brakującego klucza: pole JSON wysłane jako null, kolumna bazy danych z wartością NULL, opcja jawnie ustawiona na null, aby ją wyczyścić.

Strona o isset opisuje inne zastosowania, w tym sprawdzanie kilku zmiennych naraz.

Odróżnienie null od braku w danych JSON

Typowy przypadek, w którym poprawną odpowiedź daje tylko array_key_exists(): API aktualizujące rekord na podstawie JSON. Pole wysłane jako null oznacza „wyczyść je”, pole pominięte oznacza „nie ruszaj go”. isset() widzi oba przypadki tak samo.

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

Z isset($patch[$field]) numer telefonu by został, bo null wyglądałoby jak brakujące pole.

key_exists() to ta sama funkcja

key_exists() to alias array_key_exists(), zachowany z wczesnego PHP. Te same argumenty, ten sam wynik. Wybieraj pełną nazwę, której czytelnicy spodziewają się zobaczyć.

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

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

Typy kluczy: "1" i 1 to ten sam klucz

Klucze tablicy to liczby całkowite albo stringi, a string będący zwykłą dziesiętną liczbą całkowitą jest zapisywany jako liczba całkowita. Dlatego array_key_exists('1', $arr) znajduje klucz 1 i na odwrót. String taki jak '01' pozostaje stringiem i jest innym kluczem.

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

Sprawdzanie kluczy zagnieżdżonych i kilku kluczy

array_key_exists() patrzy na jeden poziom. Dla zagnieżdżonej ścieżki, w której null nie ma znaczenia, isset($a['x']['y']) sprawdza wszystkie poziomy naraz. Dla ścieżki, w której ma, krótka funkcja pomocnicza przechodzi przez poziomy. Aby sprawdzić, czy kilka kluczy jest obecnych, porównaj przez 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) zamienia listę nazw w klucze, aby array_diff_key() mogło porównać je z kluczami danych wejściowych; to, co zostaje, jest listą brakujących pól, gotową do komunikatu o błędzie.

Obiekty wymagają property_exists

Starsze PHP przyjmowało obiekt w array_key_exists(). PHP 8 zamiast tego rzuca TypeError. Dla obiektów property_exists() sprawdza zadeklarowaną lub dynamiczną właściwość (nawet ustawioną na null), a isset($obj->prop) działa jak isset() na tablicach.

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

Ostatnie dwie linie pokazują drugą drogę: get_object_vars() zamienia dostępne właściwości obiektu w tablicę, a wtedy działają funkcje tablicowe.