Question

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

Était-ce utile?

La solution

C'est en valeur selon le Documentation PHP.

Par défaut, les arguments de la fonction sont transmis 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, ceux-ci doivent être passés par référence.

Pour qu'un argument d'une fonction soit toujours passé par référence, ajoutez une esperluette (&) au nom de l'argument dans la définition de la 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.'
?>

Autres conseils

Il semble que beaucoup de gens soient confus par la manière dont les objets sont transmis aux fonctions et par ce qui passe par référence.Les variables d'objet sont toujours transmises par valeur, seule la valeur transmise en 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érence signifie 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 swap en :

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

En PHP, par défaut, les objets sont transmis 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, regarde ça...............

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, vois ça ..............

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.

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

En PHP 5, il existe un nouveau modèle 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 sémantiquement, l'objet entier était copié lorsqu'une variable était assignée, ou passé 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 considérer un handle comme un identifiant d'objet).

Les variables PHP sont attribuées par valeur, transmises aux fonctions par valeur et lorsqu'elles contiennent/représentent des objets, elles sont transmises par référence.Vous pouvez forcer le passage des variables par référence à l'aide d'un &

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

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

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

produirait

variable1 :test, variable2 :test final, var3 :examen final

Réussi par exemple de valeur/référence :

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

changeThem($var1, $var2);

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

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

produirait :

variable1 :foo, var2 BARRE

Variables d'objet transmises 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";
}

Cela produirait :

FOO

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

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

Vous pouvez le faire de toute façon.

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

donc

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

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

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

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 !

Lire ici : 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>";

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

Sortir:

Échanger des objets :B, A swapvalues:un B

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

Utilisez-le pour les fonctions lorsque vous souhaitez simplement modifier la variable d'origine et lui redonner le 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

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

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top