array_slice The trap of the return value without modifying the original array

gitbox 2025-05-26

In PHP development, the array_slice function is a very practical array operation function, which can cut out a specified piece of element from an array as a return value. However, many beginners and even intermediate programmers often mistakenly believe that array_slice will directly modify the original array, resulting in confusion in code logic and difficulty in debugging. This article will analyze the return value characteristics of array_slice in detail, reveal the reason why it does not modify the original array, and give examples to avoid traps.

1. Introduction to array_slice function

The basic syntax of array_slice is as follows:

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

$array : original array.
$offset : The position at which the start intercepts is supported, which indicates the countdown from the tail of the array.
$length : The intercepted length, default to the number of remaining elements in the array.
$preserve_keys : Whether to retain the key name of the original array, default false.

This function returns a new intercepted array, rather than a reference to the original array.

2. Why doesn’t array_slice modify the original array?

array_slice returns a "new array", which is composed of copying the specified interval elements from the original array. Array copying in PHP is passed by value (although the underlying implementation has copy-on-write optimization), and no in-place modification operations are performed on the passed array in the function. In other words, the original intention of array_slice is to maintain the integrity and immutability of the original array.

Therefore, when you use array_slice , what you get is the new array of intercepted results, and the original array remains unchanged.

example:

 $fruits = ['apple', 'banana', 'cherry', 'date'];
$sliced = array_slice($fruits, 1, 2);

print_r($sliced);
// Output:
// Array
// (
//     [0] => banana
//     [1] => cherry
// )

print_r($fruits);
// Output:
// Array
// (
//     [0] => apple
//     [1] => banana
//     [2] => cherry
//     [3] => date
// )

Here, the $fruits array has not been modified, and $sliced is the new array that was intercepted.

3. Common misunderstandings and traps

I mistakenly thought the original array was modified <br> Many people use array_slice and print the original array again, and find that the original array has not changed, so they suspect that the code logic is incorrect. In fact, array_slice does not change the original array.
Try to use array_slice to modify the array directly <br> Some people may write the following code:
```
 $arr = [1,2,3,4,5];
$arr = array_slice($arr, 2);
```
This is actually assigning the intercept result back to the original array variable. At this time, the variable points to the new array, and the original array is discarded. If you want to "modify" the array, you actually replace the original array with the new array, instead of the array_slice function itself changing the array.

I hope the key name remains the same, forget to pass in the parameters <br> By default, the array returned by array_slice re-index (starting from 0), unless the fourth parameter is set to true .

 $arr = ['a' => 'apple', 'b' => 'banana', 'c' => 'cherry'];
$slice = array_slice($arr, 1, 2);
print_r($slice);
// Output：
// Array
// (
//     [0] => banana
//     [1] => cherry
// )

Here the key name becomes a numeric index. If you want to retain the key name, you should pass in the fourth parameter:

 $slice = array_slice($arr, 1, 2, true);
print_r($slice);
// Output：
// Array
// (
//     [b] => banana
//     [c] => cherry
// )

4. How to use array_slice correctly to avoid problems?

It is clear that array_slice returns a new array and will not change the passed array itself.
If you want to "update" the array, you need to manually assign the value to the original variable or other variables.
Note whether you need to keep the key name and pass true to avoid loss of the key name.
Avoid confusion with array_splice , which is a function that directly modifies the original array.

5. Summary

array_slice is a function to intercept arrays in PHP. It is designed to simply return the new array without modifying the original array. This design avoids side effects and makes the code safer and maintainable. Understanding this can help developers avoid misunderstandings and traps, correctly use the array interception function, and improve code quality.

If you need to delete, insert and modify the original array, you can use array_splice , which is the function that directly changes the original array. For array intercept, array_slice is the preferred tool for immutable and returning new arrays.

array_slice