क्या PHP वैरिएबल मूल्य या संदर्भ द्वारा पारित हैं?

PHP variables are assigned by value, passed to functions by value, and when containing/representing objects are passed by reference. You can force variables to pass by reference using an &

मूल्य / संदर्भ उदाहरण द्वारा असाइन किया गया:

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

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

उत्पादन होगा

var1: परीक्षण, var2: अंतिम परीक्षण, var3: अंतिम परीक्षण

मूल्य / संदर्भ परीक्षा द्वारा उत्तीर्ण:

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

changeThem($var1, $var2);

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

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

आउटपुट होगा:

var1: foo, var2 बार

संदर्भ परीक्षा द्वारा पारित ऑब्जेक्ट वेरिएबल्स:

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

आउटपुट होगा:

FOO

(वह अंतिम उदाहरण शायद बेहतर हो सकता है ...)

यह PHP दस्तावेज़ के अनुसार मूल्य के अनुसार है।

By default, function arguments are passed by value (so that if the value of the argument within the function is changed, it does not get changed outside of the function). To allow a function to modify its arguments, they must be passed by reference.

To have an argument to a function always passed by reference, prepend an ampersand (&) to the argument name in the function definition.

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

आदिम प्रकार वाले चर को PHP5 में मान द्वारा पारित किया जाता है। वस्तुओं वाले चर को संदर्भ द्वारा पारित किया जाता है। 2006 से लिनक्स जर्नल से काफी दिलचस्प लेख है जो इस और अन्य ओओ मतभेदों का उल्लेख 4 और 5 के बीच करता है।

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

ऐसा लगता है कि बहुत से लोग कामों को पारित करने के तरीके से भ्रमित हो जाते हैं और संदर्भ के माध्यम से क्या मतलब है। ऑब्जेक्ट वेरिएबल्स अभी भी मूल्य से गुजर चुके हैं, यह केवल PHP5 में पारित मान एक संदर्भ हैंडल है। सबूत के रूप में:

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

आउटपुट:

a, b

संदर्भ द्वारा पास का अर्थ है कि हम कॉलर द्वारा देखे गए चर को संशोधित कर सकते हैं। कौन सा स्पष्ट रूप से उपरोक्त कोड नहीं करता है। हमें स्वैप फ़ंक्शन को बदलने की आवश्यकता है:

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

आउटपुट:

b, a

संदर्भ से गुजरने के लिए।

संस्करण पर निर्भर करता है, 4 मूल्य से है, 5 संदर्भ के अनुसार है।

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

PHP 5 में एक नया ऑब्जेक्ट मॉडल है। ऑब्जेक्ट्स के PHP की हैंडलिंग पूरी तरह से फिर से लिखी गई है, जिससे बेहतर प्रदर्शन और अधिक सुविधाएं मिलती हैं। PHP के पिछले संस्करणों में, वस्तुओं को आदिम प्रकारों (उदाहरण के लिए पूर्णांक और तार) के रूप में संभाला गया था। इस विधि की कमी यह थी कि जब एक चर को असाइन किया गया था, या विधि के पैरामीटर के रूप में पारित किया गया था, तो पूरी तरह से ऑब्जेक्ट की प्रतिलिपि बनाई गई थी। नए दृष्टिकोण में, ऑब्जेक्ट्स को हैंडल द्वारा संदर्भित किया जाता है, न कि मूल्य से (कोई ऑब्जेक्ट के पहचानकर्ता के रूप में हैंडल के बारे में सोच सकता है)।

PHP में, डिफ़ॉल्ट ऑब्जेक्ट्स को संदर्भ प्रतिलिपि के रूप में एक नए ऑब्जेक्ट में पास किया जाता है।

यह उदाहरण देखें .............

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

अब यह देखें ..............

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.

अब यह देखें ..............

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.

मुझे उम्मीद है कि आप इसे समझ सकते हैं।

आप एक चर को संदर्भ द्वारा एक समारोह में पारित कर सकते हैं। यह फ़ंक्शन मूल चर को संशोधित करने में सक्षम होगा।

आप फ़ंक्शन परिभाषा में संदर्भ द्वारा मार्ग को परिभाषित कर सकते हैं:

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

$result=5;
changeValue($result);

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

फ़ंक्शंस के लिए इसका उपयोग करें जब आप मूल चर को आसानी से बदलना चाहते हैं और फिर इसे उसी वैरिएबल नाम पर वापस लौटाएं, जिसका नया मान असाइन किया गया हो।

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

आप इसे किसी भी तरह से कर सकते हैं।

put a '&' symbol in front and the variable you are passing becomes one and the same as its origin. ie: you can pass by reference, rather than making a copy of it.

इसलिए

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

ऑब्जेक्ट्स PHP 5 में संदर्भ और PHP 4 में मान द्वारा पारित किए जाते हैं। वैरिएबल डिफ़ॉल्ट रूप से मूल्य से पारित कर रहे हैं!

Read here: 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() . "
";

echo 'SwapObjects: ' . $a1->getValue() . ", " . $b1->getValue() . "
";

संदर्भों द्वारा पारित नहीं होने पर गुण अभी भी संशोधित हैं इसलिए सावधान रहें।

आउटपुट:

स्वैप ऑब्जेक्ट्स: बी, ए स्वैपवैल्यूज़: ए, बी

असल में दोनों विधियां मान्य हैं लेकिन यह आपकी आवश्यकता पर निर्भर करती है। संदर्भ द्वारा पैस मान अक्सर आपकी स्क्रिप्ट को धीमा कर देता है। तो निष्पादन के समय पर विचार करके मूल्य से वैरिएबल पास करना बेहतर है। जब आप मान द्वारा चर पारित करते हैं तो कोड प्रवाह अधिक सुसंगत होता है।