¿Se pasan las variables PHP por valor o por referencia?

Parece que mucha gente se confunde por la forma en que los objetos se pasan a las funciones y lo que pasan por medios de referencia. Las variables de objeto todavía se pasan por valor, solo el valor que se pasa en PHP5 es un identificador de referencia. Como prueba:

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

Salidas:

a, b

A pasar por referencia significa que podemos modificar las variables que se ven por el llamante. Lo que claramente el código anterior no hace. Necesitamos cambiar la función swap a:

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

Salidas:

b, a

Para pasar por referencia.

En PHP, por defecto los objetos se pasan como copia de referencia a un nuevo Objeto.

Vea este ejemplo.............

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

Ahora vea esto..............

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.

Ahora vea esto ..............

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.

Espero que puedan entender esto.

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

En PHP 5 hay un nuevo Modelo de Objetos. El manejo de objetos de PHP ha sido completamente reescrito, permitiendo un mejor rendimiento y más características. En versiones anteriores de PHP, los objetos se manejaban como tipos primitivos (por ejemplo enteros y cadenas). El inconveniente de este método era que semánticamente todo el objeto se copiaba cuando se asignaba una variable, o se pasaba como parámetro a un método. En el nuevo enfoque, los objetos son referenciados por identificador, y no por valor (uno puede pensar en un identificador como el identificador de un objeto).

Las variables PHP se asignan por valor, se pasan a las funciones por valor, y cuando contienen/representan objetos se pasan por referencia. Puede forzar que las variables pasen por referencia usando un &

Asignado por valor/ejemplo de referencia:

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

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

Produciría

Var1: prueba, var2: prueba final, var3: prueba final

Aprobado por valor / examen de referencia:

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

changeThem($var1, $var2);

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

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

Produciría:

Var1: foo, var2 BAR

Objeto variables aprobadas por examen de referencia:

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

Produciría:

FOO

(ese último ejemplo podría ser mejor probablemente...)

Puede pasar una variable a una función por referencia. Esta función podrá modificar la variable original.

Puede definir el pasaje por referencia en la definición de la función:

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

$result=5;
changeValue($result);

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

Puedes hacerlo de cualquier manera.

Ponga un símbolo '&' delante y la variable que está pasando se convierte en una y la misma que su origen. ie: puede pasar por referencia, en lugar de hacer una copia de la misma.

So

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

Las variables que contienen tipos primitivos se pasan por valor en PHP5. Las variables que contienen objetos se pasan por referencia. Hay un artículo bastante interesante de Linux Journal de 2006 que menciona esta y otras diferencias de OO entre 4 y 5.

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

Los objetos se pasan por referencia en PHP 5 y por valor en PHP 4. Las Variables se pasan por valor por defecto!

Lea aquí: 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>";

Los atributos siguen siendo modificables cuando no se pasan por referencia, así que tenga cuidado.

Salida:

SwapObjects: b, a Valores de intercambio: a, b

En realidad ambos métodos son válidos, pero depende de su requisito.Pasar valores por referencia a menudo hace que su script sea lento. Así que es mejor pasar variables por valor considerando el tiempo de ejecución. También el flujo de código es más consistente cuando se pasan variables por valor.

Use esto para funciones cuando desee simplemente alterar la variable original y devolverla nuevamente al mismo nombre de variable con su nuevo valor asignado.

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

Depende de la versión, 4 es por valor, 5 es por referencia.