Frage

PHP Variablen übergeben nach Wert oder Referenz?

War es hilfreich?

Lösung

Es ist von Wert, entsprechend der In der PHP-Dokumentation.

Standardmäßig ist die Funktion Argumente als Wert übergeben werden (so dass, wenn der Wert des Arguments in der Funktion geändert wird, kann es nicht geändert werden, außerhalb der Funktion).Zu ermöglichen, eine Funktion zu ändern, die seine Argumente, Sie müssen als Referenz übergeben werden.

Haben Sie ein argument an eine Funktion immer per Referenz übergeben, stellen Sie ein kaufmännisches und-Zeichen (&), um das argument-Namen in die definition der Funktion.

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

Andere Tipps

Es scheint, dass viele Menschen verwirrt durch die Art, wie Objekte an Funktionen übergeben werden und was passieren Referenz bedeutet.Objekt-Variablen sind immer noch von Wert übergeben, es ist nur der Wert, der übergeben wird, in PHP5 ist eine Referenz Griff.Als Beweis:

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

Zu pass by reference heißt, wir können ändern Sie die Variablen, die angezeigt werden, indem der Anrufer.Die eindeutig den obigen code nicht.Wir müssen die swap-Funktion:

<?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 pass durch Referenz.

In PHP standardmäßig werden Objekte übergeben als Referenz kopieren zu einem neuen Objekt.

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

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

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, Sie können verstehen.

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

In PHP 5 gibt es ein neues Objekt-Modell.PHP ist die Handhabung von Objekten wurde komplett überarbeitet, so dass für eine bessere Leistung und mehr Funktionen.In früheren Versionen von PHP, Objekte behandelt wurden wie primitive Datentypen (z.B. ganze zahlen und strings).Der Nachteil dieser Methode war, dass semantisch das gesamte Objekt kopiert wurde, wenn eine variable zugewiesen wurde, oder übergeben Sie als parameter an eine Methode.In dem neuen Ansatz, Objekte verwiesen werden behandeln, und nicht als Wert (man denke an ein handle als Objekt-Identifikator).

PHP-Variablen zugewiesen werden, die durch Wert an Funktionen übergeben von Wert, und wenn die/repräsentieren Objekte werden per Referenz übergeben.Sie können erzwingen-Variablen zu übergeben, die durch Verweis mit einem &

Assigned by value/reference Beispiel:

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

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

ausgeben würde

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

Passed by value/reference exampe:

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

changeThem($var1, $var2);

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

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

ausgeben würde:

var1:foo, var2 BAR

Objekt-Variablen per Referenz übergeben 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";
}

Ausgeben würde:

FOO

(dieses Letzte Beispiel könnte besser sein, vermutlich...)

Übergeben Sie eine variable an eine Funktion Referenz.Diese Funktion wird in der Lage zu ändern die ursprüngliche variable.

Sie können definieren, der die passage durch Verweis in die definition der Funktion:

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

$result=5;
changeValue($result);

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

Sie können es entweder Weg.

setzen Sie ein ' & ' - symbol vor, und die variable, die Sie übergeben, wird ein und dasselbe wie seine Herkunft.ie:Sie können als Verweis übergeben, anstatt eine Kopie davon.

so

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

Variablen mit primitiven Typen übergeben werden, durch den Wert in PHP5.Variablen, die Objekte werden per Referenz übergeben.Es gibt durchaus ein interessanter Artikel aus der Linux Journal 2006, die erwähnt diese und andere OO Unterschiede zwischen 4 und 5.

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

Objekte werden per Referenz übergeben in PHP 5 by-value in PHP 4.Variablen, die als Wert übergeben werden standardmäßig!

Lesen Sie hier: 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>";

Attribute sind immer noch veränderbar, wenn Sie nicht per Referenz übergeben, so beware.

Ausgabe:

SwapObjects:b, a SwapValues:a, b

Eigentlich beide Methoden sind gültig, aber es hängt von Ihrer Anforderung.Werte übergeben durch Referenz oft macht Ihr Skript langsam.So ist es besser, übergabe von Variablen durch einen Wert, indem Sie in Anbetracht der Zeit der Ausführung.Auch die code flow wird mehr konsistent, wenn Sie die übergabe von Variablen über einen Wert.

Verwenden Sie diese Funktionen, wenn Sie möchten, einfach ändern die ursprüngliche variable und Rückkehr es wieder, um die gleiche variable name mit dem neuen Wert zugewiesen.

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

Abhängig von der version, 4 ist der Wert 5 wird verwiesen.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top