array_slice is a detail that is easily overlooked when using associative arrays

gitbox 2025-05-28

During PHP development, array_slice is one of our commonly used array operation functions. It is mainly used to extract a sub-array from an array. However, when we use it, it is easy to cause unexpected bugs if we do not pay attention to the parameters and the details of the return result. This article will reveal this "pit" with practical examples and teach you how to avoid it correctly.

1. Review of the basic usage of array_slice

array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array

$array : The original array to operate
$offset : Start location
$length : The length to be intercepted
$preserve_keys : Whether to preserve the key name of the original array (default is false , i.e. re-index)

2. An intuitive example: Associative arrays hit the pit scene

Let’s take a look at an example:

 $data = [
    'apple' => 1,
    'banana' => 2,
    'cherry' => 3,
    'date' => 4,
];

$result = array_slice($data, 1, 2);
print_r($result);

Do you think the following will be output?

 Array
(
    [banana] => 2
    [cherry] => 3
)

In fact, the output looks like this:

 Array
(
    [0] => 2
    [1] => 3
)

Why is the key name lost? The reason is that the default value of the fourth parameter $preserve_keys is false , so the key name is reset to the index key starting from 0 .

3. How to properly ensure that the keys of the associative array are retained

Just specify true to the fourth parameter when calling array_slice :

 $result = array_slice($data, 1, 2, true);
print_r($result);

The output will be as you wish:

 Array
(
    [banana] => 2
    [cherry] => 3
)

This step is critical, especially when you rely on the key names of the array (such as handling form fields, configuration files, etc.), forgetting this parameter may cause a complete logic error.

4. More hidden pit: There is a greater problem when continuing to operate the result array

For example, you use slice results to construct a new key-value structure:

 foreach (array_slice($data, 1, 2) as $key => $val) {
    echo "$key => $val\n";
}

What you expect to output is:

 banana => 2
cherry => 3

But the actual output is:

 0 => 2
1 => 3

This can make some of your key-value dependency logic completely fail, especially when you use $key as some kind of identifier.

5. Application scenario suggestions: Clarify the use scenario to determine whether to retain keys

Before you use array_slice , ask yourself:

Do you care about the key names? (The key names in the associative array are generally very important)
Will the result continue to be used for logic related to the original array key?

If the answer is "yes", be sure to set $preserve_keys = true .

6. Summary of recommended practices

Encapsulation of a safer version can avoid repeated mistakes:

 function slice_assoc(array $array, int $offset, ?int $length = null): array {
    return array_slice($array, $offset, $length, true);
}

Then use:

 $result = slice_assoc($data, 1, 2);

Clear, reliable, and error-free.

7. Further reading and actual cases

In many CMS and frameworks, array_slice is used in background pagination or configuration array processing. If the key is not retained, it may cause confusion and even cause permission verification vulnerabilities. For example, when doing pagination intercepts for a certain type of configuration item, if the key is config_id and is reset to an integer index, the corresponding configuration will not match normally.

For more precautions for using PHP functions, please check https://gitbox.net/php-tips

array_slice