PHP变量是按值传递还是按引用传递?
取决于版本，4是值，5是引用。
PHP变量按值赋值，按值传递给函数，当包含/表示对象时通过引用传递。可以使用“&”强制变量通过引用传递。
由值/引用示例赋值:
$var1 = "test";
$var2 = $var1;
$var2 = "new test";
$var3 = &$var2;
$var3 = "final test";
print ("var1: $var1, var2: $var2, var3: $var3);
输出:
Var1:测试，var2:最终测试，var3:最终测试
按值/引用示例传递:
$var1 = "foo";
$var2 = "bar";
changeThem($var1, $var2);
print "var1: $var1, var2: $var2";
function changeThem($var1, &$var2){
$var1 = "FOO";
$var2 = "BAR";
}
输出:
foo, var2 BAR
引用示例传递的对象变量:
class Foo{
public $var1;
function __construct(){
$this->var1 = "foo";
}
public function printFoo(){
print $this->var1;
}
}
$foo = new Foo();
changeFoo($foo);
$foo->printFoo();
function changeFoo($foo){
$foo->var1 = "FOO";
}
输出:
喷火
(最后一个例子可能更好。)
根据PHP文档，它是按值计算的。
默认情况下，函数实参是按值传递的(这样，如果函数内实参的值改变了，它不会在函数外被改变)。为了允许函数修改其参数，它们必须通过引用传递。 要让函数的实参始终通过引用传递，请在函数定义中的实参名称前加上&。
<?php
function add_some_extra(&$string)
{
$string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str; // outputs 'This is a string, and something extra.'
?>
http://www.php.net/manual/en/migration5.oop.php
In PHP 5 there is a new Object Model. PHP's handling of objects has been completely rewritten, allowing for better performance and more features. In previous versions of PHP, objects were handled like primitive types (for instance integers and strings). The drawback of this method was that semantically the whole object was copied when a variable was assigned, or passed as a parameter to a method. In the new approach, objects are referenced by handle, and not by value (one can think of a handle as an object's identifier).
在PHP5中，包含基本类型的变量是按值传递的。包含对象的变量是通过引用传递的。2006年的Linux Journal上有一篇非常有趣的文章提到了4和5之间的OO差异。
http://www.linuxjournal.com/article/9170
似乎很多人都对对象传递给函数的方式和引用传递的含义感到困惑。对象仍然是按值传递的，只是PHP5中传递的值是引用句柄。证明:
<?php
class Holder {
private $value;
public function __construct($value) {
$this->value = $value;
}
public function getValue() {
return $this->value;
}
}
function swap($x, $y) {
$tmp = $x;
$x = $y;
$y = $tmp;
}
$a = new Holder('a');
$b = new Holder('b');
swap($a, $b);
echo $a->getValue() . ", " . $b->getValue() . "\n";
输出:
a, b
通过引用传递意味着我们可以修改调用者看到的变量，显然上面的代码没有做到这一点。我们需要将swap函数更改为:
<?php
function swap(&$x, &$y) {
$tmp = $x;
$x = $y;
$y = $tmp;
}
$a = new Holder('a');
$b = new Holder('b');
swap($a, $b);
echo $a->getValue() . ", " . $b->getValue() . "\n";
输出:
b, a
为了通过引用传递。
两种方法都可以。
在前面放一个“&”符号，你传递的变量就变成了它的原点，也就是说，你可以通过引用传递，而不是复制它。
so
$fred = 5;
$larry = & $fred;
$larry = 8;
echo $fred;//this will output 8, as larry and fred are now the same reference.
在PHP 5中通过引用传递对象，在PHP 4中通过值传递对象。 默认情况下，变量是按值传递的!
阅读此处:http://www.webeks.net/programming/php/ampersand-operator-used-for-assigning-reference.html
class Holder
{
private $value;
public function __construct( $value )
{
$this->value = $value;
}
public function getValue()
{
return $this->value;
}
public function setValue( $value )
{
return $this->value = $value;
}
}
class Swap
{
public function SwapObjects( Holder $x, Holder $y )
{
$tmp = $x;
$x = $y;
$y = $tmp;
}
public function SwapValues( Holder $x, Holder $y )
{
$tmp = $x->getValue();
$x->setValue($y->getValue());
$y->setValue($tmp);
}
}
$a1 = new Holder('a');
$b1 = new Holder('b');
$a2 = new Holder('a');
$b2 = new Holder('b');
Swap::SwapValues($a1, $b1);
Swap::SwapObjects($a2, $b2);
echo 'SwapValues: ' . $a2->getValue() . ", " . $b2->getValue() . "<br>";
echo 'SwapObjects: ' . $a1->getValue() . ", " . $b1->getValue() . "<br>";
属性在没有通过引用传递时仍然是可以修改的，所以要小心。
输出:
SwapObjects: b, a SwapValues: a, b
在PHP中，默认情况下，对象作为新对象的引用传递。
请看这个例子:
class X {
var $abc = 10;
}
class Y {
var $abc = 20;
function changeValue($obj)
{
$obj->abc = 30;
}
}
$x = new X();
$y = new Y();
echo $x->abc; //outputs 10
$y->changeValue($x);
echo $x->abc; //outputs 30
现在看这个:
class X {
var $abc = 10;
}
class Y {
var $abc = 20;
function changeValue($obj)
{
$obj = new Y();
}
}
$x = new X();
$y = new Y();
echo $x->abc; //outputs 10
$y->changeValue($x);
echo $x->abc; //outputs 10 not 20 same as java does.
现在看这个:
class X {
var $abc = 10;
}
class Y {
var $abc = 20;
function changeValue(&$obj)
{
$obj = new Y();
}
}
$x = new X();
$y = new Y();
echo $x->abc; //outputs 10
$y->changeValue($x);
echo $x->abc; //outputs 20 not possible in java.
我希望你能理解。
可以通过引用将变量传递给函数。这个函数将能够修改原始变量。
你可以在函数定义中通过引用来定义段落:
<?php
function changeValue(&$var)
{
$var++;
}
$result=5;
changeValue($result);
echo $result; // $result is 6 here
?>
实际上这两种方法都是有效的，但这取决于你的需求。通过引用传递值通常会使脚本变慢。因此，考虑到执行时间，最好按值传递变量。此外，当按值传递变量时，代码流更加一致。
当您希望简单地更改原始变量并将其返回到相同的变量名并赋予其新值时，可以将此用于函数。
function add(&$var){ // The & is before the argument $var
$var++;
}
$a = 1;
$b = 10;
add($a);
echo "a is $a,";
add($b);
echo " a is $a, and b is $b"; // Note: $a and $b are NOT referenced
TL;DR: PHP supports both pass by value and pass by reference. References are declared using an ampersand (&); this is very similar to how C++ does it. When the formal parameter of a function is not declared with an ampersand (i.e., it's not a reference), everything is passed by value, including objects. There is no distinction between how objects and primitives are passed around. The key is to understand what gets passed along when you pass in objects to a function. This is where understanding pointers is invaluable.
对于将来遇到这种情况的人，我想分享这个来自PHP文档的精华，由一位匿名用户发布:
这里似乎有些混乱。指针和引用之间的区别并不是特别有用。 已经发布的一些“综合”示例中的行为可以用更简单的统一术语来解释。例如，Hayley的代码正在做您应该期望它应该做的事情。(使用>= 5.3)
第一个原则: 指针存储访问对象的内存地址。任何时候赋值一个对象，都会生成一个指针。(我还没有深入研究Zend引擎，但据我所知，这是适用的)
2nd principle, and source of the most confusion: Passing a variable to a function is done by default as a value pass, ie, you are working with a copy. "But objects are passed by reference!" A common misconception both here and in the Java world. I never said a copy OF WHAT. The default passing is done by value. Always. WHAT is being copied and passed, however, is the pointer. When using the "->", you will of course be accessing the same internals as the original variable in the caller function. Just using "=" will only play with copies.
3rd principle: "&" automatically and permanently sets another variable name/pointer to the same memory address as something else until you decouple them. It is correct to use the term "alias" here. Think of it as joining two pointers at the hip until forcibly separated with "unset()". This functionality exists both in the same scope and when an argument is passed to a function. Often the passed argument is called a "reference," due to certain distinctions between "passing by value" and "passing by reference" that were clearer in C and C++.
只要记住:传递给函数的是指向对象的指针，而不是对象本身。这些指针是原始指针的副本，除非在参数列表中使用“&”来实际传递原始指针。只有当你深入到一个物体的内部时，原始的东西才会改变。
下面是他们提供的例子:
<?php
//The two are meant to be the same
$a = "Clark Kent"; //a==Clark Kent
$b = &$a; //The two will now share the same fate.
$b="Superman"; // $a=="Superman" too.
echo $a;
echo $a="Clark Kent"; // $b=="Clark Kent" too.
unset($b); // $b divorced from $a
$b="Bizarro";
echo $a; // $a=="Clark Kent" still, since $b is a free agent pointer now.
//The two are NOT meant to be the same.
$c="King";
$d="Pretender to the Throne";
echo $c."\n"; // $c=="King"
echo $d."\n"; // $d=="Pretender to the Throne"
swapByValue($c, $d);
echo $c."\n"; // $c=="King"
echo $d."\n"; // $d=="Pretender to the Throne"
swapByRef($c, $d);
echo $c."\n"; // $c=="Pretender to the Throne"
echo $d."\n"; // $d=="King"
function swapByValue($x, $y){
$temp=$x;
$x=$y;
$y=$temp;
//All this beautiful work will disappear
//because it was done on COPIES of pointers.
//The originals pointers still point as they did.
}
function swapByRef(&$x, &$y){
$temp=$x;
$x=$y;
$y=$temp;
//Note the parameter list: now we switched 'em REAL good.
}
?>
关于JavaScript的这个主题，我写了一篇广泛而详细的博客文章，但我相信它同样适用于PHP、c++和任何其他人们似乎对按值传递和按引用传递感到困惑的语言。
Clearly, PHP, like C++, is a language that does support pass by reference. By default, objects are passed by value. When working with variables that store objects, it helps to see those variables as pointers (because that is fundamentally what they are, at the assembly level). If you pass a pointer by value, you can still "trace" the pointer and modify the properties of the object being pointed to. What you cannot do is have it point to a different object. Only if you explicitly declare a parameter as being passed by reference will you be able to do that.
关于如何将对象传递给函数，你仍然需要理解，没有“&”，你传递给函数的是一个对象句柄，对象句柄仍然是通过值传递的，它包含一个指针的值。但你不能改变这个指针，直到你通过引用传递它使用“&”
<?php
class Example
{
public $value;
}
function test1($x)
{
//let's say $x is 0x34313131
$x->value = 1; //will reflect outsite of this function
//php use pointer 0x34313131 and search for the
//address of 'value' and change it to 1
}
function test2($x)
{
//$x is 0x34313131
$x = new Example;
//now $x is 0x88888888
//this will NOT reflect outside of this function
//you need to rewrite it as "test2(&$x)"
$x->value = 1000; //this is 1000 JUST inside this function
}
$example = new Example;
$example->value = 0;
test1($example); // $example->value changed to 1
test2($example); // $example did NOT changed to a new object
// $example->value is still 1
?>
PHP引用是一个别名，允许两个不同的变量写入相同的值。
在PHP中，如果你有一个包含对象的变量，这个变量不包含对象本身。相反，它包含该对象的标识符。对象访问器将使用标识符查找实际对象。因此，当我们在函数中使用对象作为参数或将其赋值给另一个变量时，我们将复制指向对象本身的标识符。
https://hsalem.com/posts/you-think-you-know-php.html
class Type {}
$x = new Type();
$y = $x;
$y = "New value";
var_dump($x); // Will print the object.
var_dump($y); // Will print the "New value"
$z = &$x; // $z is a reference of $x
$z = "New value";
var_dump($x); // Will print "New value"
var_dump($z); // Will print "New value"