una - paso de parametros por valor y por referencia php




¿Las variables PHP se pasan por valor o por referencia? (9)

¿Las variables PHP se pasan por valor o por referencia?


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


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

Ver 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 mira 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 mira 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 puedas entender esto.


Es por valor de acuerdo con la documentación de PHP .

Por defecto, los argumentos de la función se pasan por valor (de modo que si se cambia el valor del argumento dentro de la función, no se cambia fuera de la función). Para permitir que una función modifique sus argumentos, se deben pasar por referencia.

Para tener un argumento para una función siempre pasado por referencia, anteponga un signo de y comercial ( & ) al nombre del argumento en la definición de la función.

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

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);

saldría

var1: prueba, var2: prueba final, var3: prueba final

Aprobado por valor / referencia examen:

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

changeThem($var1, $var2);

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

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

daría salida:

var1: foo, var2 BAR

Variables de objeto pasadas 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";
}

Daría salida:

FOO

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



Parece que mucha gente se confunde por la forma en que se pasan los objetos a las funciones y por lo que pasa por 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

Pasar por referencia significa que podemos modificar las variables que ve la persona que llama. Lo que claramente no hace el código anterior. Necesitamos cambiar la función de intercambio 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.


Puedes hacerlo de cualquier manera.

ponga un símbolo '&' al frente y la variable que está pasando se convierte en una y la misma que su origen. es decir: puede pasar por referencia, en lugar de hacer una copia de la misma.

entonces

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

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 &amp; 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

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 SwapValues: a, b







pass-by-value