Reassignment of a variable referencing an array reassigns the original variable - php

Question

I have this code:
$originalBar = [
'baz' => 18
];
function modify (&$bar) {
$bar['test'] = true;
$bar = [
'data' => 42
];
global $originalBar;
echo 'same ' . ($bar === $originalBar) . PHP_EOL;
}
modify($originalBar);
var_dump($originalBar);
I know that since the function accepts an argument by reference, any passed array will be modified. So I expect to change the original array with:
$bar['test'] = true;
...and set key test of $originalBar to true. However, when I reassign $bar I expect that the variable no longer points to the original array ($originalBar) and any changes onwards don't modify it. Obviously, that's not the case because the output is:
same 1
array(1) {
["data"]=>
int(42)
}
By reassigning $bar, I reassigned $originalBar too. I expected that this would function the same way as it does in JavaScript, which is why I was confused at first.
My question is - is this documented somewhere? I read the Passing by Reference documentation but I didn't find that there.
Edit: If instead of doing this in the modify function:
$bar = [
'data' => 42
];
...I do this:
$arr = [
'data' => 42
];
$bar = &$arr;
...I get my initially expected result:
same
array(2) {
["baz"]=>
int(18)
["test"]=>
bool(true)
}
It's interesting that in this case, $originalBar is not assigned to the value of $arr and keeps its old value instead.

Answer 1

I'd like to correct some misapprehensions in the question, comments, and self-answer.
Passing objects in PHP behave similarly to passing objects in JS. This is not passing by reference, but passing an "object pointer" by value; the difference is subtle but important. When you pass a variable into a function by reference, you can assign any value to that variable inside the function, and it will have that value on the outside of the function as well. Passing an object does not give you this ability - you can't replace it with a different object, or with the value 42 - but it does let you mutate the object - you can call a method or set a property, and the code outside the function will be able to see the result.
The difference between JS and PHP here is that arrays in JS are objects, but in PHP they are not, so they do not have this "mutable object pointer" behaviour when passed by value.
Pass by reference, as implemented in PHP and many other languages, means that any assignment or modification of the variable inside the function is reflected outside the function. There is nothing special about arrays here, the same thing happens with $foo=42; or $foo++;.
JS does not have an equivalent for explicit pass-by-reference, but other languages such as C# and Pascal have the same concept with different syntaxes.
Things get more unusual in PHP when you assign by reference ($foo =& $bar); one way to think of it is that you have one variable, and you're giving it two names.
I prefer to spell what you wrote as $bar = &$newValue as $bar =& $newValue, because the action isn't really "assign something to $bar" but "bind the name $bar as an alias for something". In binding that alias, it discards any previous binding for that name, so it undoes the "pass by reference" nature of the name.

Answer 2

A possible point of confusion is that arrays in PHP are not the same as arrays/objects in JS and instead behave like strings or numbers for pass-by-value purposes.
In PHP, arrays passed by value will be copied on write when dirtied in a function, much like strings or numerical types:
function modify($a) {
global $foo;
var_dump($a === $foo); # => true
$a['hello'] = "world";
var_dump($a === $foo); # => false, we wrote to $a and it was copied.
}
$foo = ["baz" => 42];
modify($foo);
var_dump($foo); # => ["baz" => 42] (the original was unchanged after the function call)
From a JS perspective, we might expect that $a['hello'] = "world"; would reflect on the outer object and not cause a copy to be created:
const modify = a => {
console.log(a === foo); // => true
a.hello = "world";
console.log(a === foo); // => true
};
const foo = {bar: "baz"};
modify(foo);
console.log(foo); // => {"bar": "baz", "hello": "world"}
The pass-by-value behavior in PHP is unsurprising on objects:
class A {
function __construct() {
$this->bar = "hello";
}
}
function modify($a) {
global $foo;
var_dump($a === $foo); # => true
$a->bar = "world";
var_dump($a === $foo); # => true
}
$foo = new A();
modify($foo);
var_dump($foo); /* => object(A)#1 (1) {
["bar"]=>
string(5) "world"
}
*/
In PHP, passing by reference enables mutation of the original array:
function modify(&$a) {
global $foo;
var_dump($a === $foo); # => true
$a['hello'] = "world";
var_dump($a === $foo); # => true
}
$foo = ["baz" => 42];
modify($foo);
print_r($foo); # => ["baz" => 42, "hello" => "world"]
A reference variable can also be reassigned to a new value:
function modify(&$a) {
global $foo;
var_dump($a === $foo); # => true
$a = "world";
var_dump($a === $foo); # => true
}
$foo = ["baz" => 42];
modify($foo);
print_r($foo); # => "world"
Since JS does't support passing by reference, there is no clear parallel between JS and PHP for these behaviors, aside from the usage of the reference operator to support JS/object-like mutations of arrays inside a function.

Answer 3

That's not documented anywhere because it's the expected behavior. I have just misread. The PHP docs say:
You can pass a variable by reference to a function so the function can modify the variable.
I've had the wrong impression because objects are passed by reference by default in JavaScript and there, reassigning the argument variable doesn't change the original variable.
The intention of passing by reference in PHP is to be able to modify the variable, not just the object it points to. Meaning, you can not only change the object, but also reassign the passed variable.
As #ggorlen said in the comments to my question:
The reference operator is really doing two things: 1) exposing the original memory location for reassignment and 2) allowing a complex structure such as an array to be mutated. In JS, the first is never possible and the second is always possible. PHP gives some "flexibility" in these regards where on the one hand, function ($var) is much more restrictive than most langs while function (&$var) is more permissive than most languages, which is not exactly intuitive.