Werden PHP-Variablen als Wert oder als Referenz übergeben?

Translate

Werden PHP-Variablen als Wert oder als Referenz übergeben?

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

Alle Antworten

Translate

Es ist nach Wert nach demPHP-Dokumentation.

Standardmäßig werden Funktionsargumente als Wert übergeben (sodass der Wert des Arguments innerhalb der Funktion nicht außerhalb der Funktion geändert wird, wenn er geändert wird). Damit eine Funktion ihre Argumente ändern kann, müssen sie als Referenz übergeben werden.

Stellen Sie ein kaufmännisches Und voran, um ein Argument für eine Funktion zu erhalten, die immer als Referenz übergeben wird (&) zum Argumentnamen in der Funktionsdefinition.

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

Es scheint, dass viele Leute verwirrt sind, wie Objekte an Funktionen übergeben werden und was als Referenzmittel übergeben wird. Objektvariablen werden immer noch als Wert übergeben. Es ist nur der Wert, der in PHP5 übergeben wird, ein Referenzhandle. Als Beweis dafür:

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

Ausgänge:

a, b

Zuals Referenz übergebenbedeutet, dass wir die Variablen ändern können, die vom Aufrufer gesehen werden. Was der obige Code eindeutig nicht tut. Wir müssen die Swap-Funktion ändern in:

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

Ausgänge:

b, a

um als Referenz zu übergeben.

Quelle
Translate

In PHP werden Objekte standardmäßig als Referenzkopie an ein neues Objekt übergeben.

Siehe dieses Beispiel .............

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

Jetzt sehen Sie das ..............

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.

Jetzt sehen Sie das ..............

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.

Ich hoffe du kannst das verstehen.

Quelle
Translate

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

In PHP 5 gibt es ein neues Objektmodell. Der Umgang von PHP mit Objekten wurde komplett neu geschrieben, um eine bessere Leistung und mehr Funktionen zu ermöglichen. In früheren Versionen von PHP wurden Objekte wie primitive Typen behandelt (z. B. Ganzzahlen und Zeichenfolgen). Der Nachteil dieser Methode war, dass semantisch das gesamte Objekt kopiert wurde, als eine Variable zugewiesen oder als Parameter an eine Methode übergeben wurde. Bei dem neuen Ansatz wird auf Objekte nach Handle und nicht nach Wert verwiesen (man kann sich ein Handle als Objektkennung vorstellen).

Quelle
Translate

PHP-Variablen werden nach Wert zugewiesen, nach Wert an Funktionen übergeben und beim Enthalten / Darstellen von Objekten als Referenz übergeben. Mit einem & können Sie die Übergabe von Variablen als Referenz erzwingen

Zugewiesen nach Wert / Referenzbeispiel:

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

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

würde ausgeben

var1: Test, var2: Abschlusstest, var3: Abschlusstest

Übergeben von Wert / Referenz-Exampe:

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

changeThem($var1, $var2);

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

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

würde ausgeben:

var1: foo, var2 BAR

Objektvariablen, die als Referenz übergeben werden:

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

Würde ausgeben:

FOO

(Das letzte Beispiel könnte wahrscheinlich besser sein ...)

Quelle
Translate

Sie können eine Variable als Referenz an eine Funktion übergeben. Diese Funktion kann die ursprüngliche Variable ändern.

Sie können die Passage durch Bezugnahme in der Funktionsdefinition definieren:

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

$result=5;
changeValue($result);

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

Sie können es so oder so tun.

Setzen Sie ein '&' Symbol vor und die Variable, die Sie übergeben, wird ein und dieselbe wie ihr Ursprung. dh: Sie können als Referenz übergeben, anstatt eine Kopie davon zu erstellen.

damit

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

Variablen, die primitive Typen enthalten, werden in PHP5 als Wert übergeben. Variablen, die Objekte enthalten, werden als Referenz übergeben. Es gibt einen interessanten Artikel aus dem Linux Journal aus dem Jahr 2006, in dem dieser und andere OO-Unterschiede zwischen 4 und 5 erwähnt werden.

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

Quelle
Translate

Objekte werden in PHP 5 als Referenz und in PHP 4 als Wert übergeben. Variablen werden standardmäßig als Wert übergeben!

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

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

Attribute können weiterhin geändert werden, wenn sie nicht als Referenz übergeben werden.

Ausgabe:

SwapObjects: b, a SwapValues: a, b

Quelle
Translate

Eigentlich sind beide Methoden gültig, aber es hängt von Ihren Anforderungen ab. Pass-Werte als Referenz machen Ihr Skript oft langsam. Es ist daher besser, Variablen nach Wert zu übergeben, indem der Ausführungszeitpunkt berücksichtigt wird. Außerdem ist der Codefluss konsistenter, wenn Sie Variablen nach Wert übergeben.

Quelle
Translate

Verwenden Sie diese Option für Funktionen, wenn Sie die ursprüngliche Variable einfach ändern und sie wieder auf denselben Variablennamen mit dem neuen zugewiesenen Wert zurücksetzen möchten.

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
Quelle
PPL
Translate

Abhängig von der Version ist 4 nach Wert, 5 nach Referenz.

Quelle