Sunt PHP Variabile transmise prin valoare sau prin referință?

L's de valoare conform Documentatia PHP.

implicit, funcția argumentele sunt transmise prin valoare (astfel încât, dacă valoarea argumentului în funcție este schimbat, nu te-a schimbat în afara funcției). Pentru a permite o funcție pentru a modifica argumentele sale, acestea trebuie să fie transmise prin referință.

Pentru a avea un argument pentru o funcție întotdeauna transmis prin referință, adauga un ampersand (&) pentru argumentul numele în definiția funcției.

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

Se pare că o mulțime de oameni a obține confuz de modul în care obiectele sunt trecute la funcțiile și ce trece de referință înseamnă. Obiect variabile sunt încă transmise prin valoare, doar valoarea care este trecut în PHP5 este o referință mâner. Ca dovada:

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

Ieșiri:

a, b

A a trece de referință înseamnă că putem modifica variabilele care sunt văzute de către apelant. Care în mod clar codul de mai sus nu face. Avem nevoie pentru a schimba funcția de swap pentru 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";

Ieșiri:

b, a

în scopul de a trece de referință.

În PHP, implicit, obiectele sunt trecut ca referință copia un Obiect nou.

Vezi acest exemplu.............

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

Acum vezi asta..............

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.

Acum vezi asta ..............

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.

sper că puteți înțelege asta.

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

În PHP 5 este un nou Model de Obiect. PHP's manipulare de obiecte a fost complet rescris, pentru a permite o performanță mai bună și mai multe caracteristici. În versiunile anterioare ale PHP, obiectele au fost tratate ca tipuri primitive (de exemplu numere întregi și siruri de caractere). Dezavantajul acestei metode a fost că semantic întregul obiect a fost copiat atunci când o variabilă a fost atribuit, sau a trecut ca un parametru într-o metodă. În noua abordare, obiecte sunt referite de manevrat, și nu de valoare (se poate gândi de un mâner ca un obiect's de identificare).

PHP variabilele sunt alocate prin valoare, a trecut la funcțiile de valoare, și atunci când conțin/reprezentând obiectele sunt transmise prin referință. Puteți forța de variabile pentru a trece de referință folosind o &

Atribuit de valoare/de referință, de exemplu:

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

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

ar ieșire

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

A trecut de valoare/de referință exampe:

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

changeThem($var1, $var2);

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

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

ar ieșire:

var1: foo, var2 BAR

Obiect variabile transmise prin referință exampe:

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

Ar ieșire:

FOO

(ultimul exemplu ar putea fi mai bine, probabil...)

Puteți trece o variabilă a unei funcții prin referință. Această funcție va fi capabil de a modifica variabila originală.

Puteți defini trecerea de referință în funcție de definiție:

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

$result=5;
changeValue($result);

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

O poti face oricum.

pune o '&' simbol în față și variabila ce trece devine unul și același lucru ca și originea sa. de exemplu: puteți trece de referință, mai degrabă decât a face o copie.

deci

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

Variabilele care conțin tipuri primitive sunt transmise prin valoare în PHP5. Variabilele conțin obiectele sunt transmise prin referință. Nu's destul de un interesant articol din Linux Journal din 2006, care menționează acest lucru și alte OO diferențe între 4 și 5.

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

Obiectele sunt transmise prin referință în PHP 5 și de valoare în PHP 4. Variabilele sunt transmise prin valoare, în mod implicit!

Citeste aici: 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>";

Atributele sunt încă modificabile, când nu a trecut de referință, deci atentie.

Ieșire:

SwapObjects: b, o SwapValues: a, b

Utilizați această pentru funcțiile atunci când doriți să pur și simplu modifica variabila originală și să se întoarcă din nou la același nume de variabilă cu noua sa valoare atribuită.

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

De fapt, ambele metode sunt valabile, dar aceasta depinde de cerințele dumneavoastră.Trece valorile de referință de multe ori face script-ul lent. Deci, este mai bine pentru a trece variabile de valoare de având în vedere timpul de execuție. De asemenea, fluxul de cod este mai consistent atunci când treci variabile de valoare.

Depinde de versiune, 4 este de valoare, 5 este de referință.