end() may cause side effects when using it with reference arrays

M66 2025-05-17

In PHP, the end() function is a commonly used array function that points the inner pointer of the array to the last element and returns the value of that element. This operation is very useful for handling most arrays. However, when you use the end() function to manipulate a reference array, some unexpected side effects may be caused. This article will explain why this happens and provide some relevant examples.

Basic usage of end() function

In PHP, the syntax of the end() function is very simple:

 mixed end ( array &$array )

$array is the array you want to operate on, and end() will move the internal pointer of the array to the last element of the array and return the value of that element. It should be noted that end() will change the internal pointer position of the array, which means that the next time you use current() , prev() , next() and other functions, it will be based on the new internal pointer position.

Reference arrays and side effects

The problem usually occurs when using reference arrays. Reference arrays are arrays passed to functions by reference, so any modifications made to the array will affect the contents of the original array.

Consider the following code example:

 $array = [1, 2, 3, 4];
$refArray = &$array;  // Passing an array using reference

$lastElement = end($refArray);  // Move the pointer to the last element

echo $lastElement;  // Output 4
echo $array[0];  // Output 4

In this example, $refArray is a reference to $array . Therefore, the end() function will not only affect $refArray , but also the original $array . Since end() changes the internal pointer of the array, this causes the first element of $array to become the last element of the array, i.e. 4 . This is the manifestation of side effects.

Why are there any side effects?

The root cause of this side effect is the internal working mechanism of PHP arrays. When you use a reference array, PHP does not create a new copy, but directly operates on the original array. This means that the pointer state of the array (i.e., "current pointer position") is shared. If you call end() on the reference array, the pointer of the array will move to the last element, affecting the position of the original array.

Therefore, if your code depends on the current position of the array pointer, or the order of the array itself (such as loop traversal, etc.), it is possible to cause side effects due to the use of the end() function.

How to avoid side effects?

To avoid this side effect, you can use the end() function without changing the pointer position of the original array. There are several ways to avoid this problem:

Use a copy of the array:

Avoid directly modifying the original array by creating a copy of the array. For example:

 $array = [1, 2, 3, 4];
$arrayCopy = $array;  // Create a copy of the array
$lastElement = end($arrayCopy);  // Does not affect the original array

echo $lastElement;  // Output 4
echo $array[0];  // Output 1（The original array has not changed）

Manually reset the array pointer:
If you do need to change the pointer position of the array, use the reset() function to reposition the pointer to the beginning of the array, which can reduce the risk of subsequent code being affected. For example:
```
 $array = [1, 2, 3, 4];
end($array);  // Move the pointer to the end
reset($array);  // Reset the pointer back to the beginning

echo current($array);  // Output 1
```

Avoid using reference arrays:

Passing a copy of the array directly, rather than referencing the array, can avoid this problem of pointer sharing. For example:

 $array = [1, 2, 3, 4];
$lastElement = end($array);  // Pass the copy directly，No references are used

echo $lastElement;  // Output 4
echo $array[0];  // Output 1（The original array has not changed）

in conclusion

The end() function is a very useful tool in PHP, but it can cause unexpected side effects when dealing with reference arrays. Since end() changes the internal pointer position of the array, it may affect subsequent operations of the original array. Therefore, when using end() , you need to be careful, especially when using reference arrays. By creating a copy of the array, resetting the array pointer, or avoiding the use of referenced arrays, these side effects can be effectively avoided and ensure the correctness and predictability of the code.