Переменные PHP передаются по значению или по ссылке?

В зависимости от версии, 4 - по значению, 5 - по ссылке.

Переменные PHP назначаются по значению, передаются функциям по значению, а когда они содержат / представляют объекты, передаются по ссылке. Вы можете принудительно передать переменные по ссылке с помощью символа '&'.

Присваивается по значению / справочному примеру:

$var1 = "test";
$var2 = $var1;
$var2 = "new test";
$var3 = &$var2;
$var3 = "final test";

print ("var1: $var1, var2: $var2, var3: $var3);

выход:

var1: test, var2: final test, var3: final test

Передано по значению / справочному примеру:

$var1 = "foo";
$var2 = "bar";

changeThem($var1, $var2);

print "var1: $var1, var2: $var2";

function changeThem($var1, &$var2){
    $var1 = "FOO";
    $var2 = "BAR";
}

выход:

var1: 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";
}

выход:

FOO

(Последний пример, наверное, мог бы быть лучше.)

Это по стоимости согласно Документация PHP.

By default, function arguments are passed by value (so that if the value of the argument within the function is changed, it does not get changed outside of the function). To allow a function to modify its arguments, they must be passed by reference.

To have an argument to a function always passed by reference, prepend an ampersand (&) to the argument name in the function definition.

<?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 передаются по значению. Переменные, содержащие объекты, передаются по ссылке. В Linux Journal от 2006 года есть довольно интересная статья, в которой упоминается это и другие объектно-ориентированные различия между 4 и 5.

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

пройти по ссылке означает, что мы можем изменять переменные, которые видит вызывающий, чего явно не делает приведенный выше код. Нам нужно изменить функцию подкачки на:

<?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

для того, чтобы пройти по ссылке.

Вы можете сделать это в любом случае.

Поместите символ '&' впереди, и переменная, которую вы передаете, станет той же самой, что и ее происхождение, то есть вы можете передавать по ссылке, а не делать ее копию.

так

    $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 поддерживает как передачу по значению, так и передачу по ссылке. Ссылки объявляются с использованием амперсанда (&); это очень похоже на то, как это делает C++. Когда формальный параметр функции не объявлен с амперсандом (т.е. это не ссылка), все передается по значению, включая объекты. Нет различия между тем, как передаются объекты и примитивы. Ключ в том, чтобы понять, что Какие передается, когда вы передаете объекты в функцию. Здесь бесценно понимание указателей.

Для всех, кто столкнется с этим в будущем, я хочу поделиться этой жемчужиной из Документы PHP, опубликованные анонимным пользователем:

There seems to be some confusion here. The distinction between pointers and references is not particularly helpful. The behavior in some of the "comprehensive" examples already posted can be explained in simpler unifying terms. Hayley's code, for example, is doing EXACTLY what you should expect it should. (Using >= 5.3)

First principle: A pointer stores a memory address to access an object. Any time an object is assigned, a pointer is generated. (I haven't delved TOO deeply into the Zend engine yet, but as far as I can see, this applies)

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++.

Just remember: pointers to objects, not objects themselves, are passed to functions. These pointers are COPIES of the original unless you use "&" in your parameter list to actually pass the originals. Only when you dig into the internals of an object will the originals change.

И вот пример, который они предоставляют:

<?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++ и любому другому языку, где люди, кажется, не понимают, что такое передача по значению или передача по ссылке.

Ясно, что PHP, как и C++, - это язык, который поддерживает передачу по ссылке. По умолчанию объекты передаются по значению. При работе с переменными, в которых хранятся объекты, полезно видеть эти переменные как указатели (потому что это, по сути, то, чем они являются на уровне сборки). Если вы передаете указатель по значению, вы все равно можете «отслеживать» указатель и изменять свойства объекта, на который он указывает. Чего вы не можете сделать, так это указать ему на другой объект. Только если вы явно объявите параметр как передаваемый по ссылке, вы сможете это сделать.