Czy zmienne PHP są przekazywane przez wartość czy przez odniesienie?

Wydaje się, że wielu ludzi jest zdezorientowanych sposobem przekazywania obiektów do funkcji i tym, co przechodzi przez środki odniesienia. Zmienne obiektu są nadal przekazywane przez wartość, jej tylko wartość, która jest przekazywana w PHP5 jest uchwyt odniesienia. Jako dowód:

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

Wyjścia:

a, b

To pass by reference oznacza, że możemy modyfikować zmienne, które są widziane przez wywołującego. Czego oczywiście powyższy kod nie robi. Musimy zmienić funkcję swap do:

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

Wyjścia:

b, a

Aby przejść przez odniesienie.

W PHP domyślnie obiekty są przekazywane jako kopia odniesienia do nowego obiektu.

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.

Http://www.php.net/manual/en/migration5.oop.php

W PHP 5 JEST NOWY model obiektowy. Obsługa PHP obiektów została całkowicie przepisana, co pozwala na lepszą wydajność i więcej funkcji. W poprzednich wersjach PHP obiekty były traktowane jak prymitywne typy (na przykład liczby całkowite i ciągi znaków). Wadą tej metody było to, że semantycznie cały obiekt został skopiowany, gdy zmienna została przypisana, lub przekazany jako parametr do metody. W nowym approach, obiekty są odwoływane przez uchwyt, a nie przez wartość (można myśleć o uchwycie jako o identyfikatorze obiektu).

Zmienne PHP są przypisywane przez wartość, przekazywane do funkcji przez wartość, a gdy zawierają / reprezentują obiekty są przekazywane przez odniesienie. Można wymusić przekazywanie zmiennych przez odniesienie za pomocą &

Przypisany przez wartość / przykład odniesienia:

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

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

Wyszłoby

Var1: test, var2: test końcowy, var3: test końcowy

Przekazywana przez wartość / przykład odniesienia:

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

changeThem($var1, $var2);

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

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

Wyszłoby:

Var1: foo, var2 BAR

Obiekt zmienne przekazywane przez przykład odniesienia:

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

Wyszłoby:

FOO

(ten ostatni przykład mógłby być prawdopodobnie lepszy...)

Możesz przekazać zmienną do funkcji przez odniesienie. Ta funkcja będzie mogła zmodyfikować oryginalną zmienną.

Możesz zdefiniować fragment przez odniesienie w definicji funkcji:

<?php
function changeValue(&$var)
{
    $var++;
}

$result=5;
changeValue($result);

echo $result; // $result is 6 here
?>

Możesz to zrobić tak czy inaczej.

Umieść symbol ' & ' z przodu, a zmienna, którą przekazujesz, stanie się taka sama jak jej początek. ie: możesz przejść przez odniesienie, zamiast robić kopię.

Więc

    $fred = 5;
    $larry = & $fred;
    $larry = 8;
    echo $fred;//this will output 8, as larry and fred are now the same reference.

Zmienne zawierające typy prymitywne są przekazywane przez wartość w PHP5. Zmienne zawierające obiekty są przekazywane przez odniesienie. Jest dość ciekawy artykuł z Linux Journal z 2006 roku, który wspomina o tym i innych różnicach OO pomiędzy 4 a 5.

Http://www.linuxjournal.com/article/9170

Obiekty są przekazywane przez odniesienie w PHP 5 i przez wartość w PHP 4. Zmienne są domyślnie przekazywane przez wartość!

Przeczytaj tutaj: 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>";

Atrybuty są nadal modyfikowane, gdy nie są przekazywane przez odniesienie, Więc uważaj.

Wyjście:

SwapObjects: b, a SwapValues: A, b

W rzeczywistości obie metody są ważne, ale zależy to od twoich wymagań.Przekazywanie wartości przez odniesienie często powoduje spowolnienie skryptu. Więc lepiej przekazać zmienne przez wartość, biorąc pod uwagę czas wykonania. Również przepływ kodu jest bardziej spójny, gdy przekazujesz zmienne według wartości.

Użyj tego dla funkcji, gdy chcesz po prostu zmienić oryginalną zmienną i zwrócić ją ponownie do tej samej nazwy zmiennej z przypisaną nową wartością.

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

Zależy od wersji, 4 jest przez wartość, 5 jest przez odniesienie.