Deep Analysis of PHP Array Passing Mechanisms: Value Copy vs Reference Passing

PHP Array Assignment Mechanism

In PHP, array assignment defaults to value copying. As explicitly stated in the PHP manual: "Array assignment always involves value copying. Use the reference operator to copy an array by reference." This means that when executing an assignment like $b = $a;, $b receives an independent copy of the $a array, not a reference to the original array.

The following code example clearly demonstrates this behavior:

<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // Modify $arr2
// $arr1 remains array(2, 3), $arr2 becomes array(2, 3, 4)
?>

If you need to create a reference to the original array, you must explicitly use the reference operator &:

<?php
$arr1 = array(2, 3);
$arr3 = &$arr1;
$arr3[] = 4; // Modify $arr3
// Both $arr1 and $arr3 become array(2, 3, 4) as they reference the same array
?>

Function Parameter Passing Mechanism

The default parameter passing method in PHP functions is pass-by-value. This means when an array is passed as a parameter to a function, the function receives a copy of that array, and modifications to the copy do not affect the original array.

Consider this example:

<?php
function my_func($a) {
    $a[] = 30;
}

$arr = array(10, 20);
my_func($arr);
var_dump($arr); // Output: array(10, 20), original array unchanged
?>

To modify the original array within a function, you must use pass-by-reference. This is achieved by prefixing the parameter with & in the function definition:

<?php
function my_func(&$a) {
    $a[] = 30;
}

$arr = array(10, 20);
my_func($arr);
var_dump($arr); // Output: array(10, 20, 30), original array modified
?>

Copy-on-Write Optimization Mechanism

PHP internally employs a copy-on-write mechanism to optimize memory usage. When an array is passed to a function non-referentially and the function only reads the array content, PHP does not immediately create a full copy but uses internal references, thus avoiding unnecessary memory consumption.

This mechanism can be verified through memory usage testing:

<?php
function printUsedMemory($arr) {
    $start_memory = memory_get_usage();
    
    // Read-only operations
    count($arr);
    $x = $arr[0];
    $arr[0] - $arr[1];
    
    echo memory_get_usage() - $start_memory; // Minimal memory increase
}

$x = array_fill(0, 10000, 1); // Create large array
printUsedMemory($x);
?>

However, once the array is modified within the function, the copy-on-write mechanism triggers, creating a full copy of the array:

<?php
function printUsedMemory($arr) {
    $start_memory = memory_get_usage();
    
    $arr[0] = 1; // Write operation triggers copying
    
    echo memory_get_usage() - $start_memory; // Significant memory increase
}

$x = array_fill(0, 10000, 1);
printUsedMemory($x);
?>

Summary of Three Passing Scenarios

Based on the above analysis, three main scenarios of PHP array passing can be summarized:

1. Read-Only Scenario: When a function only reads the array parameter without modification, PHP uses internal reference passing, avoiding memory copying, exhibiting reference-like behavior.
2. Modification Scenario: When a function modifies a non-reference parameter, the copy-on-write mechanism triggers, creating an array copy, with modifications affecting only the copy, exhibiting pass-by-value behavior.
3. Explicit Reference Scenario: When using the & symbol to explicitly specify reference passing, the function directly operates on the original array, with all modifications taking effect immediately.

This design balances memory efficiency with code predictability. Developers can choose the appropriate passing method based on specific needs: use default pass-by-value when ensuring original data is not accidentally modified; use reference passing when functions need to modify original data or optimize large array processing.

Understanding these mechanisms is crucial for writing efficient and reliable PHP code. It is recommended to select the most suitable array handling approach based on specific scenarios in actual development and refer to the PHP official documentation for detailed explanations about references and arrays when necessary.