Les variables PHP sont-elles transmises par valeur ou par référence?

Translate

Les variables PHP sont-elles passées par valeur ou par référence?

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

C'est par valeur selon leDocumentation PHP.

Par défaut, les arguments de fonction sont passés par valeur (de sorte que si la valeur de l'argument dans la fonction est modifiée, elle ne le sera pas en dehors de la fonction). Pour permettre à une fonction de modifier ses arguments, ils doivent être passés par référence.

Pour que l'argument d'une fonction soit toujours passé par référence, ajoutez une esperluette (&) au nom de l'argument dans la définition de fonction.

<?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.'
?>
La source
Translate

Il semble que beaucoup de gens soient confus par la façon dont les objets sont passés aux fonctions et par ce que signifie passer par référence. Les variables d'objet sont toujours passées par valeur, c'est juste la valeur qui est passée dans PHP5 est un handle de référence. Comme preuve:

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

Les sorties:

a, b

Àpasser par référencesignifie que nous pouvons modifier les variables vues par l'appelant. Ce que le code ci-dessus ne fait clairement pas. Nous devons changer la fonction d'échange pour:

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

Les sorties:

b, a

afin de passer par référence.

La source
Translate

En PHP, les objets par défaut sont passés comme copie de référence à un nouvel objet.

Voir cet exemple .............

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

Maintenant, voyez ceci ..............

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.

Maintenant, voyez ceci ..............

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.

j'espère que vous pouvez comprendre cela.

La source
Translate

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

En PHP 5, il existe un nouveau modèle d'objet. La gestion des objets par PHP a été complètement réécrite, permettant de meilleures performances et plus de fonctionnalités. Dans les versions précédentes de PHP, les objets étaient traités comme des types primitifs (par exemple des entiers et des chaînes). L'inconvénient de cette méthode était que, d'un point de vue sémantique, l'objet entier était copié lorsqu'une variable était assignée ou passée en paramètre à une méthode. Dans la nouvelle approche, les objets sont référencés par handle, et non par valeur (on peut penser à un handle comme identifiant d'un objet).

La source
Translate

Les variables PHP sont affectées par valeur, passées aux fonctions par valeur et lorsqu'elles contiennent / représentent des objets, elles sont passées par référence. Vous pouvez forcer les variables à passer par référence en utilisant un &

Affecté par valeur / exemple de référence:

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

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

sortirait

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

Passé par valeur / exemple de référence:

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

changeThem($var1, $var2);

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

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

produirait:

var1: toto, var2 BAR

Variables d'objet passées par exemple de référence:

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

Produirait:

FOO

(ce dernier exemple pourrait être probablement meilleur ...)

La source
Translate

Vous pouvez passer une variable à une fonction par référence. Cette fonction pourra modifier la variable d'origine.

Vous pouvez définir le passage par référence dans la définition de la fonction:

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

$result=5;
changeValue($result);

echo $result; // $result is 6 here
?>
La source
Translate

Vous pouvez le faire de toute façon.

placez un symbole '&' devant et la variable que vous passez devient une et la même que son origine. c'est-à-dire: vous pouvez passer par référence, plutôt que d'en faire une copie.

alors

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

Les variables contenant des types primitifs sont passées par valeur en PHP5. Les variables contenant des objets sont passées par référence. Il y a un article assez intéressant du Linux Journal de 2006 qui mentionne ceci et d'autres différences OO entre 4 et 5.

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

La source
Translate

Les objets sont passés par référence en PHP 5 et par valeur en PHP 4. Les variables sont passées par valeur par défaut!

Lisez ici:http://www.webeks.net/programming/php/ampersand-operator-used-for-assigning-reference.html

La source
Translate
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>";

Les attributs sont toujours modifiables lorsqu'ils ne sont pas passés par référence, alors méfiez-vous.

Production:

SwapObjects: b, a SwapValues: a, b

La source
Translate

En fait, les deux méthodes sont valides mais cela dépend de vos besoins. Les valeurs de passage par référence ralentissent souvent votre script. Il est donc préférable de passer les variables par valeur en tenant compte du moment de l'exécution. De plus, le flux de code est plus cohérent lorsque vous passez des variables par valeur.

La source
Translate

Utilisez cette option pour les fonctions lorsque vous souhaitez simplement modifier la variable d'origine et la renvoyer au même nom de variable avec sa nouvelle valeur attribuée.

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
La source
PPL
Translate

Dépend de la version, 4 par valeur, 5 par référence.

La source