Pass-by-reference in PHP does not improve performance with large arrays or objects due to copy-on-write and object handles, so it should not be used for that purpose; 1. Use pass-by-reference only when you need to modify the original variable, such as swapping values or returning multiple values via function parameters; 2. Avoid it for performance gains because modern PHP already optimizes value passing; 3. Be cautious of side effects, persistent references in loops, and unintended modifications; 4. Prefer returning new values for cleaner, safer, and more testable code; 5. Reserve references for rare cases where profiling shows a benefit or when required by external code, treating them like a sharp tool—useful when necessary but dangerous if overused.

PHP’s pass-by-reference feature can be a powerful tool when used correctly, but it’s often misunderstood and misapplied, leading to confusing bugs or false assumptions about performance. Let’s break down how pass-by-reference works in PHP, when it helps, and where it can backfire.

What Is Pass-by-Reference?

In PHP, variables are normally passed by value. That means when you pass a variable to a function, a copy of its value is made. Any changes inside the function don’t affect the original variable.

Pass-by-reference, on the other hand, allows a function to modify the original variable directly. You indicate this by using the & symbol in the function parameter definition:

function increment(&$value) {
    $value  ;
}

$number = 5;
increment($number);
echo $number; // Outputs: 6

Here, $number is passed by reference, so the function modifies it directly.

Performance: Does It Help?

A common misconception is that passing large arrays or objects by reference significantly improves performance by avoiding memory copying. But this is largely outdated in modern PHP.

Since PHP 5 and especially PHP 7 , PHP uses copy-on-write and object handles:

• Arrays and strings: PHP doesn’t actually copy large variables when passing by value unless they are modified. Thanks to copy-on-write semantics, the data is shared until a write occurs.
• Objects: As of PHP 5, objects are passed by reference by default (more precisely, by object handle), so using & on object parameters is unnecessary and doesn’t improve performance.

So, for most cases:

• Passing large arrays by reference won’t make your code faster.
• The performance gain is negligible or nonexistent in practice.
• The engine already optimizes value passing efficiently.

Only in rare cases—like repeatedly modifying a large array inside multiple functions—might a reference offer a tiny edge, but readability and maintainability should come first.

Common Pitfalls and Gotchas

While references can be useful, they introduce complexity and subtle bugs.

1. Unintended Side Effects

Because references allow functions to change the original variable, it can make code harder to reason about:

function process(&$items) {
    sort($items);
}

$list = [3, 1, 2];
process($list);
// $list is now sorted—maybe you didn’t expect that!

This side effect isn’t obvious unless you check the function definition. It breaks the expectation that functions don’t alter inputs.

2. References Persist in Loops

One of the most notorious pitfalls involves foreach and references:

$array = [1, 2, 3];
foreach ($array as &$value) {
    $value *= 2;
}
// $value still references the last element!

foreach ($array as $value) {
    // This will overwrite the last element!
}
print_r($array); // Last element may be unexpectedly changed

Always unset the reference after the loop:

unset($value);

3. Returning References (Advanced Use)

You can return references, but it’s rare and risky:

function &getStaticValue() {
    static $value = 0;
    return $value;
}

$ref = &getStaticValue();
$ref = 42;
echo getStaticValue(); // Outputs: 42

This can be useful for implementing certain patterns (like singleton property access), but it’s easy to create tightly coupled, hard-to-test code.

When Should You Use Pass-by-Reference?

Use pass-by-reference only when:

• You need to return multiple values from a function:

  function swap(&$a, &$b) {
      $temp = $a;
      $a = $b;
      $b = $temp;
  }

• You’re working with external APIs or frameworks that require it.
• You’re implementing performance-critical code and profiling shows a real benefit (rare).

Otherwise, prefer returning values:

function processData($data) {
    // modify and return new value
    return array_map('trim', $data);
}

This is cleaner, safer, and easier to test.

Bottom Line

Pass-by-reference in PHP is not a performance shortcut. The engine already handles large data efficiently. Misusing references leads to side effects, bugs, and code that’s hard to debug.

Use it sparingly and only when the intent is clear: modifying the original variable is the explicit goal. In most cases, embrace immutability and return new values instead.

Basically, treat & like a sharp tool—useful in the right hands, dangerous when overused.

The above is the detailed content of Understanding PHP's Pass-by-Reference: Performance and Pitfalls. For more information, please follow other related articles on the PHP Chinese website!