Definition and Usage

The array_key_exists() function checks if a specific key (or index) exists in an array.

If the specified key (or index) is found, the function returns true. Otherwise, it returns false.

This function is is commonly used to verify if a specific key (or index) exists in an array, which is useful for validating array structure and ensuring expected keys are present.

Basic Example

PHP 
$settings = [
    'theme' => 'dark',
    'language' => 'en',
    'show_errors' => true
];

if (array_key_exists('language', $settings)) {
    echo 'Language setting is defined.';
} else {
    echo 'Language setting is not defined.';
}

// Output: 'Language setting is defined.'

This example demonstrates how array_key_exists() is used to check whether a particular key exists within an array. This is important because accessing an undefined key could lead to errors or unexpected behavior. By verifying the presence of keys beforehand, you can write safer and more reliable code.

In practice, array_key_exists() is often used for validating configuration arrays, ensuring necessary data keys are included, and controlling program flow based on the existence of specific keys.

While the array_key_exists() function is often used with associative arrays, it can also be used with indexed arrays. In this case, the numerical indexes (starting from 0) act as the keys. This allows you to check if a specific index exists in a standard indexed array.

The following is a simple example that uses array_key_exists() to check whether a specific index key exists in an indexed array.

PHP 
$colors = ['red', 'green', 'blue'];

if (array_key_exists(1, $colors)) {
    echo "Index 1 exists in the array and its value is: " . $colors[1];
} else {
    echo "Index 1 does not exist in the array.";
}

// Output: Index 1 exists in the array and its value is: green

Syntax

PHP 
array_key_exists(mixed $key, array $array): bool

Parameters

Description of the array_key_exists() function parameters
$key Required. Specifies the key to search for in the array.
$array Required. The array to be searched.

Return Values

Returns true if the searched key exists in the array; otherwise, returns false.

Important:
array_key_exists() will only search keys at the top level of the array. It will not check for keys inside nested arrays.

Changelog

Version history for array_key_exists() Function
VersionDescription
8.0.0 The $key parameter now accepts values of type bool, float, int, null, resource, and string.
8.0.0 Passing an object to the $array parameter is no longer supported.
7.4.0 Passing an object to the $array parameter has been deprecated. Use property_exists() if you need to check for object properties.

Practical Examples

The array_key_exists() function in PHP is a useful tool for checking whether a specific key exists in an array. Here are several practical examples of how it can be used effectively.

Basic Usage

PHP 
$studentScores = [
    'Alice' => 85,
    'Bob' => 90,
    'Charlie' => 78,
    'David' => 95
];

if (array_key_exists('Bob', $studentScores)) {
    echo "Bob's score is available in the array.";
} else {
    echo "Bob's score is not found in the array.";
}
Output:

In this example, the function array_key_exists('Bob', $studentScores) checks whether the key 'Bob' exists in the $studentScores array. Since it does, the function returns true, and the message "Bob's score is available in the array." is printed.

This basic usage demonstrates how array_key_exists() can be used to confirm the presence of a specific key before attempting to access its value, which helps prevent runtime errors in your code.

Checking Multiple Keys with a Loop

The array_key_exists() function is designed to check for a single key at a time. To check multiple keys in an array, you can combine it with a foreach loop.

PHP 
// Array to search
$myArray = [
    'key1' => 'value1',
    'key2' => 'value2',
    'key3' => 'value3',
    // ... more keys
];

// Keys to check
$keysToCheck = ['key1', 'key2', 'key5', 'key7'];

// Loop through the keys
foreach ($keysToCheck as $key) {
    if (array_key_exists($key, $myArray)) {
        echo "Key '$key' exists in the array." . '<br>';
    } else {
        echo "Key '$key' does not exist in the array." . '<br>';
    }
}

Code Explanation
The foreach loop is commonly used to iterate over arrays or objects.

Output:

In this example, each key from the $keysToCheck array is evaluated using array_key_exists() to determine whether it exists in $myArray. This approach allows you to check for multiple keys efficiently within a loop.

Using isset() as an Alternative (PHP 5.6+)

Starting with PHP 5.6, you can also use the isset() function as a substitute for array_key_exists() when checking for the presence of keys.

PHP 
// Array to search
$myArray = [
    'key1' => 'value1',
    'key2' => 'value2',
    'key3' => 'value3',
    // ... more keys
];

// Keys to check
$keysToCheck = ['key1', 'key2', 'key5', 'key7'];

foreach ($keysToCheck as $key) {
    if (isset($myArray[$key])) {
        echo "Key '$key' exists in the array." . '<br>';
    } else {
        echo "Key '$key' does not exist in the array." . '<br>';
    }
}
Output:

While both array_key_exists() and isset() can be used to check if a key exists in an array, there are subtle differences:

  • array_key_exists() returns true even if the key’s value is null.
  • isset() returns false if the key exists but its value is null.

For most everyday use cases, especially when you're sure values won't be null, isset() offers slightly better performance. Use the one that best fits your scenario.

Checking Keys in Multidimensional Arrays

By default, array_key_exists() only checks for keys at the first (top) level of an array. However, you can check keys in nested arrays by explicitly accessing each level as shown in the example below.

This means that while array_key_exists() cannot directly check deep nested keys in one call, you can combine multiple calls to verify keys step-by-step at each dimension.

This approach is particularly useful for working with structured data like configuration arrays, allowing you to ensure that each required key exists before accessing its value, thus preventing errors.

PHP 
$config = [
    'database' => [
        'host' => 'localhost',
        'username' => 'myuser',
        'password' => 'mypassword',
        // ...
    ],
    // ...
];

if (array_key_exists('database', $config) && array_key_exists('username', $config['database'])) {
    echo 'Database information is configured.';
} else {
    echo 'Database information is missing or improperly configured.';
}

Note:
Always check parent keys first before accessing nested keys to avoid warnings or errors. For example, do not call array_key_exists('username', $config['database']) without first verifying that 'database' exists in $config.

Output:

Multilingual Application

In a multilingual application, you often need to display different messages based on the selected language. By checking if the language key exists in the language array, you can safely access the corresponding messages without causing errors.

PHP 
$lang = [
    'en' => [
        'greeting' => 'Hello',
        // ...
    ],
    'es' => [
        'greeting' => '¡Hola',
        // ...
    ],
    // ...
];

$selectedLanguage = 'es'; // User-selected language

if (array_key_exists($selectedLanguage, $lang)) {
    echo $lang[$selectedLanguage]['greeting'];
} else {
    echo "Selected language is not supported.";
}
Output:

In this example, since $selectedLanguage is set to 'es', the Spanish greeting "¡Hola" is output. This demonstrates how you can use array_key_exists() to verify the presence of a language key in a multilingual application before accessing its messages.

In this way, the array_key_exists() function is a fast and convenient tool for checking whether a specific key exists in an array. It can be used in various scenarios to validate data and structure your program’s logic effectively.

References

See also