How to Check if a PHP Array Is Associative or Sequential

By the end of this page, you will understand how PHP array keys work, how to tell whether an array is sequential or associative, and which approaches are best in modern and older PHP versions. You will also see practical examples, common mistakes, and how this check is used in real applications.

PHP uses one array type for both:

• Lists: values stored with numeric keys in order, usually starting at 0
• Associative arrays: values stored with named keys

That means this is valid in PHP:

$items = ['a', 'b', 'c'];

and so is this:

$items = ['first' => 'a', 'second' => 'b'];

Internally, both are arrays.

The difference is in the keys.

A sequential array (often called a list) usually has keys like this:

[0, 1, 2, 3]

An associative array has keys like this:

['name', 'email', 'role']

or even numeric keys that are not a continuous sequence:

[ => ,  => ]

Think of a PHP array like a set of labeled storage boxes.

• A sequential array is like boxes on a shelf labeled 0, 1, 2, 3 with no missing numbers.
• An associative array is like boxes labeled fruit1, fruit2, veg1, veg2.

If the labels are perfect shelf positions starting at 0, it is a list. If the labels are custom names, or the numbers skip around, it is associative for practical purposes.

Another way to think about it:

• List = “a row of items”
• Associative array = “a lookup table”

Your check is really asking:

Are these values arranged in a clean row, or are they stored by custom labels?

Modern PHP: array_is_list()

If you are using PHP 8.1 or later, use this:

$sequentialArray = ['apple', 'orange', 'tomato', 'carrot'];
$assocArray = [
    'fruit1' => 'apple',
    'fruit2' => 'orange',
    'veg1' => 'tomato',
    'veg2' => 'carrot'
];

var_dump(array_is_list($sequentialArray)); // true
var_dump(array_is_list($assocArray));      // false

This is the best option because it is:

• readable
• built into PHP
• designed for exactly this purpose

Older PHP versions

If array_is_list() is not available, a common approach is:

function is_list_array(array ): 
{
     () === (, () - );
}

Consider this function:

function is_list_array(array $array): bool
{
    if ($array === []) {
        return true;
    }

    return array_keys($array) === range(0, count($array) - 1);
}

$data = ['apple', 'orange', 'tomato'];
$result = is_list_array($data);
var_dump($result);

Here is what happens step by step:

1. $data is created:

   ['apple', 'orange', 'tomato']
   

   PHP automatically gives it these keys:

   [, , ]
   

1. Choosing how to encode data for JSON

When sending data to a frontend or API, you may need to know whether something should be treated like a list or an object-like map.

$data = ['apple', 'orange'];

This behaves like a collection of values.

But this:

$data = ['first' => 'apple', 'second' => 'orange'];

behaves more like labeled fields.

2. Validating API input

Suppose an endpoint expects a list of user IDs:

[12, 18, 25]

You may reject input like:

['admin' => 12, 'editor' => 18]

because it is not the expected shape.

3. Processing form or configuration data

Some configuration values are key/value pairs:

[
    'host' => ,
     => 
]

In real projects, developers rarely check array type just for curiosity. They usually do it because the code must branch into different behavior.

Common patterns

Guard clauses

Reject invalid input early:

function processIds(array $ids): void
{
    if (!array_is_list($ids)) {
        throw new InvalidArgumentException('Expected a list of IDs.');
    }

    foreach ($ids as $id) {
        // Process each ID
    }
}

Validation

Frameworks and service classes often validate not just values, but also structure.

function validateTags(array $tags): bool
{
    if (!array_is_list($tags)) {
        return false;
    }

    foreach (  ) {
         (!()) {
             ;
        }
    }

     ;
}

1. Assuming numeric keys always mean a list

This is wrong:

$array = [2 => 'apple', 3 => 'orange'];

These are numeric keys, but it is not a sequential list starting at 0.

2. Forgetting gaps in keys

Broken assumption:

$array = [0 => 'apple', 2 => 'orange'];

This is not a list because key 1 is missing.

3. Using isset($array[0]) as the only test

Broken example:

function isListWrong(array $array): bool
{
    return isset($array[0]);
}

Why it is wrong:

• it only checks one key

Associative vs sequential

Quick rule

A PHP array is a list if its keys are exactly:

0, 1, 2, ..., n-1

with no gaps and in order.

Best modern solution

array_is_list($array)

• Available in PHP 8.1+
• Returns true for sequential arrays
• Returns false for associative or non-sequential arrays

Older PHP fallback

function is_list_array(array $array): bool
{
    if ($array === []) {
        return true;
    }

    return array_keys($array) === range(0, count($array) - 1);
}

Examples

How do I check if an array is associative in PHP?

A common approach is to check whether it is not a list:

$isAssociative = !array_is_list($array);

In older PHP versions, use a custom helper instead.

Is there a built-in PHP function for checking list arrays?

Yes. In PHP 8.1 and later, use:

array_is_list($array)

Are arrays with numeric keys always sequential?

No. Numeric keys like [1 => 'a', 2 => 'b'] are not sequential lists if they do not start at 0.

Does an empty array count as a list?

Usually yes. It contains no invalid keys, so it is generally treated as a valid empty list.

What is the difference between associative and sequential arrays in PHP?

A sequential array has keys 0 through n-1 in order. An associative array uses custom keys such as strings, or numeric keys that are not a continuous sequence.

Why does this matter when working with JSON or APIs?

Because your code may need to treat a collection of items differently from a key/value object structure. Validation and transformation often depend on that distinction.

What should I use in older PHP versions before 8.1?

• PHP arrays — This is the foundation, because both list-like and associative structures use the same array type.
• Array keys in PHP — Understanding numeric and string keys is essential to knowing what makes an array sequential.
• array_is_list() — This built-in function is the modern solution for this exact problem.
• array_keys() — Often used in custom list-checking helpers.
• range() — Useful for generating the expected sequential key pattern.
• JSON encoding in PHP — Array shape can affect how data is represented and consumed.
• Input validation — Structure checks are common when validating request payloads and configuration.
• foreach loops — Developers often loop differently depending on whether data is list-like or key/value-based.