In PHP, arrays are passed by value by default, but the original array can be modified by reference pass. 1. By default, a copy is created when an array is passed as a parameter, and the modifications within the function will not affect the external array; 2. Use the & symbol to explicitly pass by reference, so that the modifications to the array in the function will be reflected to the outside; 3. Since PHP 7, the copy-on-write mechanism is used to optimize performance, and the array is only actually copied when it is modified; 4. Return the array always returns a copy, even if the original array is passed in as a reference; 5. For large data sets that need to be frequently modified, it is recommended to use objects to replace the array to obtain behavior similar to reference passing.

In PHP, whether an array is passed by value or by reference depends on how you're using it in your code. By default, arrays are passed by value , not by reference. That means when you pass an array to a function, a copy of the array is made, and any changes inside the function won't affect the original array outside.

If you want to modify the original array inside a function, you need to explicitly pass it by reference using the & symbol.

How Arrays Are Passed by Default (By Value)

When you pass an array to a function normally, PHP makes a copy of that array. This is important for preventing unintended side effects in your code.

 function modifyArray($arr) {
    $arr[] = 'new item';
}

$myArray = [1, 2, 3];
modifyArray($myArray);
print_r($myArray); // Output: Array ( [0] => 1 [1] => 2 [2] => 3 )

Even though we added an item inside the function, the original array remains unchanged because only the copy was modified.

This behavior has changed slightly over time:

• Before PHP 7, arrays were copied eagerly (always duplicated).
• From PHP 7 onward, PHP uses copy-on-write , meaning the array is only copied if you modify it inside the function — which improves performance.

Passing Arrays by Reference

If you want a function to modify the original array, you need to pass it by reference using the ampersand ( & ) before the parameter:

 function modifyArrayByReference(&$arr) {
    $arr[] = 'new item';
}

$myArray = [1, 2, 3];
modifyArrayByReference($myArray);
print_r($myArray); // Output: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 'new item' )

Now the change inside the function affects the original array.

Here's what to remember about passing by reference:

• It can be useful when working with large arrays to avoid unnecessary copying.
• But it also introduces side effects, making code harder to debug or follow.

Some common use cases include:

• Modifying configuration arrays inside functions
• Building up data structures across multiple steps
• Performance-sensitive loops where memory matters

Returning Arrays from Functions

Returning an array from a function always returns a copy. Even if the array was passed by reference into the function, returning it gives you a new array.

 function getModifiedCopy($arr) {
    $arr[] = 'copied';
    return $arr;
}

$a = [1, 2];
$b = getModifiedCopy($a);
// Both $a and $b exist separately now

PHP handles this efficiently under the hood thanks to optimizations like copy-on-write, so you usually don't have to worry about performance unless you're dealing with extremely large datasets.

When You Might Want to Use Objects instead

If you're frequently modifying large data sets and want to avoid copying, consider using an object instead of an array. Objects in PHP are always passed by reference-like behavior (technically passed by handle).

 class DataContainer {
    public $items = [];
}

function modifyObject($obj) {
    $obj->items[] = 'added';
}

$obj = new DataContainer();
$obj->items = [1, 2, 3];

modifyObject($obj);
print_r($obj->items); // Output includes 'added'

This behaves similarly to passing arrays by reference but may be more appropriate in complex applications.

So to sum up:

• Arrays are passed by value by default
• Use & to pass them by reference
• PHP optimizes internally with copy-on-write
• Returning arrays creates a copy
• Consider using objects if you need consistent reference behavior

Basically that's it.

The above is the detailed content of is a php array passed by value or by reference. For more information, please follow other related articles on the PHP Chinese website!