Word PHP Veranderlikes wat deur waarde of deur verwysing?

Question

Is PHP veranderlikes wat deur waarde of deur verwysing?

Answer 1

Dit is deur waarde volgens die PHP dokumentasie .

  

By verstek, is funksie argumente wat deur waarde (so dat indien die waarde van die argument binne die funksie verander, beteken dit nie raak verander buite die funksie). Om 'n funksie toe te laat om sy argumente verander, moet hulle geslaag deur verwysing.

     

Om 'n argument om 'n funksie altyd verby verwysing, plaas 'n ampersand het ( ) om die naam argument in die funksie definisie.

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

Answer 2

Dit lyk baie mense verwar word deur die manier waarop voorwerpe geslaag om funksies en wat met die pad verbygaan verwysing beteken. Voorwerp veranderlikes nog verbygaan waarde, dit is net die waarde wat geslaag in PHP5 is 'n verwysing handvatsel. As bewys:

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

Uitsette:

a, b

Om href="http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_reference" slaag met verwysing beteken dat ons die veranderlikes wat gesien word deur die oproeper kan verander . Wat duidelik die kode hierbo nie doen. Ons moet die swap funksie verander na:

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

Uitsette:

b, a

ten einde te slaag deur verwysing.

Answer 3

In PHP, by verstek voorwerpe geslaag as verwysing kopie na 'n nuwe voorwerp.

Sien hierdie voorbeeld .............

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

Nou sien hierdie ..............

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.

Nou sien hierdie ..............

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.

Ek hoop jy kan dit verstaan.

Answer 4

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

  

In PHP 5 is daar 'n nuwe Object Model. PHP se hantering van voorwerpe is heeltemal herskryf, wat toelaat vir beter prestasie en meer funksies. In vorige weergawes van PHP, is voorwerpe hanteer soos primitiewe tipes (byvoorbeeld heelgetalle en snare). Die nadeel van hierdie metode is dat semanties die hele voorwerp is gekopieer wanneer 'n veranderlike toegeken is, of verby as 'n parameter na 'n metode. In die nuwe benadering, is voorwerpe verwys deur handvatsel, en nie deur waarde ( 'n mens kan dink aan 'n handvatsel as identifiseerder 'n voorwerp se).

Answer 5

PHP veranderlikes wat deur waarde, geslaag om funksies deur waarde, en toe met / wat voorwerpe wat deur verwysing. Jy kan veranderlikes te dwing om te slaag deur verwysing met behulp van 'n &

In opdrag van waarde / verwysing voorbeeld:

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

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

sou uitvoer

  

var1: toets, VAR2: finale toets, var3: finale toets

Geslaag deur waarde / verwysing exampe:

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

changeThem($var1, $var2);

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

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

sou uitset:

  

var1: cat, VAR2 BAR

Object veranderlikes wat deur verwysing 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";
}

Sou uitset:

  

FOO

(wat verlede voorbeeld beter waarskynlik kan wees ...)

Answer 6

Jy kan 'n veranderlike te slaag om 'n funksie by verwysing. Hierdie funksie sal in staat wees om die oorspronklike veranderlike verander.

Jy kan die gang te definieer met verwysing in die funksie definisie:

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

$result=5;
changeValue($result);

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

Answer 7

Jy kan dit óf manier doen.

sit 'n '& 'n simbool in die voorkant en die veranderlike jy verby word een en dieselfde as die oorsprong daarvan. dit wil sê:. jy kan slaag deur verwysing, eerder as om 'n afskrif daarvan

so

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

Answer 8

Veranderlikes wat primitief tipes is verby waarde in PHP5. Veranderlikes bevat voorwerpe wat deur verwysing. Daar is nogal 'n interessante artikel van Linux Journal van 2006, wat hierdie en ander OO verskille tussen 4 en 5.

noem

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

Answer 9

voorwerpe geslaag deur verwysing in PHP 5 en deur waarde in PHP 4. Veranderlikes wat deur waarde by verstek!

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

Answer 10

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

eienskappe is nog modifiable toe nie deur verwysing geslaag so pasop.

Uitgawe:

SwapObjects: b, 'n SwapValues: a, b

Answer 11

Eintlik beide die metodes is geldig, maar dit hang af van jou requirement.Pass waardes deur verwysing dikwels maak jou script stadig. Sodat sy beter om veranderlikes te slaag deur waarde deur die oorweging van tyd van die uitvoering. Ook die kode vloei is meer konsekwent as jy veranderlikes verbygaan waarde.

Answer 12

Gebruik hierdie vir funksies wanneer jy wil die oorspronklike veranderlike eenvoudig verander en stuur dit weer aan dieselfde veranderlike naam met sy nuwe waarde toegeken.

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

Answer 13

Dit hang af van die weergawe, 4 is deur waarde, 5 is deur verwysing.