PHP's =& operator creates variable references, so that multiple variables point to the same data, and modifying one will affect the other; 2. Its legal uses include returning references from a function, processing legacy code and specific variable operations; 3. However, it is easy to cause problems such as not releasing references after loops, unexpected side effects, and debugging difficulties; 4. In modern PHP, objects are passed by reference handles by default, and arrays and strings are copied on write-time, and performance optimization no longer requires manual references; 5. The best practice is to avoid using =& in ordinary assignments, and unset references in time after loops, and only use parameter references when necessary and document descriptions; 6. In most cases, safer and clear object-oriented design should be preferred, and =& should be used with caution only when a very small number of clear needs.

PHP's reference assignment operator ( =& ) is one of those features that give you a lot of power—but with that power comes the potential for confusion, bugs, and hard-to-debug issues if used carefully. While references can be useful in specific scenarios, they behave very differently from regular variable assignment and require a solid understanding to use safely.

Let's break down what =& really does, where it can help, and why it's often best avoided.

What =& Actually Does

In PHP, the = operator assigns by value , meaning a copy of the data is made:

 $a = 10;
$b = $a; // $b gets a copy of $a's value
$b = 20; // $a remains 10

But when you use =& , you're creating a reference —two variable names that point to the same underlying data:

 $a = 10;
$b =& $a; // $b now references $a
$b = 20; // $a also becomes 20
echo $a; // Outputs: 20

Now, $a and $b are effectively aliases of each other. Any change through one affects the other.

? Important: This is not the same as object assignment in modern PHP. Since PHP 5, objects are assigned by reference semantics (technically, via object handles), but that's automatic and doesn't require =& .

Legitimate Uses of =& (Rare but Real)

Although its risks, there are a few cases where =& was historically useful:

1. Returning References from Functions

If you need a function to return a reference to a variable (eg, for modifying a global or static value), you can do:

 function &getCounter() {
    static $count = 0;
    return $count;
}

$counter =& getCounter();
$counter ;
echo getCounter(); // Outputs: 1

This allows direct modification of the static variable through the returned reference.

2. Working with Legacy Code or APIs

Some older PHP frameworks or extensions (like early versions of PEAR) used =& for performance or design reasons, especially before PHP's engine optimized value copying (copy-on-write). You might still encounter it in old codebases.

3. Swapping or Manipulating Variables Directly

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

Though here, we're using pass-by-reference in parameters ( &$a ), not =& . The =& operator is for assignment, not parameter declaration.

The Perils of Misusing =&

Although its utility in edge cases, =& comes with several pitfalls.

? Confusing Behavior in Loops

A classic gotcha involves foreach and references:

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

$value = 100; // This changes the last element of $array!

Even after the loop, $value remains a reference. If you reuse $value later, you might accidentally modify the array. Always unset the reference:

 unset($value); // Break the reference

? Unexpected Side Effects

Because references link variables, changes in one place can ripple unexpectedly:

 $original = "hello";
$temp =& $original;

// Later in code...
$temp = "modified";

echo $original; // "modified" — maybe not what you expected!

This makes code harder to reason about, especially when references are passed around or used in complex scopes.

? Debugging Headaches

When variables are linked via references, var_dump() or debug_backtrace() won't clearly show that two variables are bound together. Tracking down why a variable changed “on its own” can be frustrating.

Modern PHP: You Probably Don't Need =&

Thanks to improvements in PHP's engine (especially copy-on-write semantics and object handle semantics), most performance reasons for using =& have disappeared.

• Objects are already handled by reference-like semantics:

   $obj1 = new stdClass();
  $obj2 = $obj1; // No need for =& — they refer to the same object
  $obj2->prop = 'test';
  echo $obj1->prop; // 'test'

• Arrays and strings are copied only when modified (copy-on-write), so assigning them doesn't cause performance issues.

In short: avoid =& unless you have a very specific, well-justified reason.

---

Best Practices

If you must use references, follow these guidelines:

• ? Avoid =& in regular variable assignment. It's rarely needed.
• ? Unset references after foreach loops to prevent lingering side effects.
• ? Use pass-by-reference in function parameters ( function foo(&$var) ) only when necessary (eg, modifying caller's variable).
• ? Document clearly when references are used—future maintainers (including you) will thank you.
• ? Prefer object-oriented patterns over manual reference management.

---

Final Thoughts

The =& operator is a low-level tool that exposes a sharp edge. While it gives fine-grained control over variable identity, it often leads to fragile, hard-to-follow code. In most modern PHP applications, it's obsolete.

Use it sparingly, understand it deeply, and always ask: Is there a cleaner, safer way?

Most of the time, the answer is yes.

The above is the detailed content of The Power and Peril of Reference Assignment (`=&`) in PHP. For more information, please follow other related articles on the PHP Chinese website!