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

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

0
जोड़ा संपादित
विचारों: 1
जोड़ा लेखक nawfal, स्रोत

13 उत्तर

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

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

0
जोड़ा
"ऑब्जेक्ट्स" PHP5 में मान नहीं हैं और "पास" नहीं हो सकते हैं। $ foo का मान ऑब्जेक्ट पर पॉइंटर है। $ foo मान द्वारा पारित किया गया है फ़ंक्शन changeFoo() पर, changeFoo() के रूप में इसके पैरामीटर घोषित नहीं किया गया है एक और के साथ।
जोड़ा लेखक newacct, स्रोत

यह 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.'
?>
0
जोड़ा
मुझे यह संदेह भी था (नौसिखिया) - तो बस स्पष्ट होना, यह $ str = add_some_extra ($ str) जैसा ही होगा; अगर मैं संदर्भ का उपयोग नहीं कर रहा था, है ना? तो उसमें वास्तविक जोड़ा मूल्य क्या है?
जोड़ा लेखक Obmerk Kronen, स्रोत
@ ओबमेरक यदि आप संदर्भ द्वारा संकेत देने के लिए एम्पर्सेंड का उपयोग करके नहीं थे, तो यह समकक्ष नहीं होगा। ध्यान दें कि फ़ंक्शन में कोई रिटर्न स्टेटमेंट नहीं है, इसलिए आपके मामले में $ str को शून्य सौंपा जाएगा।
जोड़ा लेखक Kimberly W, स्रोत
यदि आप इसे @ ओबमेरकक्रोनन करते हैं तो आपको मूल्य वापस करना होगा और इसे अपने कोड के माध्यम से भी पकड़ना होगा। प्रारंभिक चर अन्यथा वही रहेगा।
जोड़ा लेखक Nabeel Khan, स्रोत
मैं सोच रहा हूं कि संदर्भ द्वारा पास कुछ प्रदर्शन लाभ हैं या नहीं? मैं एक बड़ी सरणी पास कर रहा हूं और डिफ़ॉल्ट रूप से यह मूल्य से गुजरता है। तो, अगर मैं संदर्भ द्वारा कॉल का उपयोग करता हूं, तो क्या कुछ प्रदर्शन लाभ होगा ??? (पूरी प्रक्रिया के दौरान सरणी मान अपरिवर्तित रखते हुए)
जोड़ा लेखक Choxx, स्रोत
असली लाभ यह है कि आप बहु मूल्यों में हेरफेर / वापसी कर सकते हैं। आप संदर्भ द्वारा वैरिएबल पास करने में भी सक्षम हैं और फिर भी फ़ंक्शन को कुछ वापस करने दें।
जोड़ा लेखक MA-Maddin, स्रोत

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

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

0
जोड़ा
फ़ंक्शन के पैरामीटर में कोई और नहीं है, तो सभी चर PHP में मान द्वारा पारित किए जाते हैं।
जोड़ा लेखक newacct, स्रोत

ऐसा लगता है कि बहुत से लोग कामों को पारित करने के तरीके से भ्रमित हो जाते हैं और संदर्भ के माध्यम से क्या मतलब है। ऑब्जेक्ट वेरिएबल्स अभी भी मूल्य से गुजर चुके हैं, यह केवल 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

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

0
जोड़ा
यह सबूत नहीं है । पहले उदाहरण का आउटपुट बिल्कुल वही है जो आप उम्मीद करेंगे कि पूरे ऑब्जेक्ट का वर्तमान मान स्वैप फ़ंक्शन पर पास किया गया था; दूसरे शब्दों में, यदि वस्तुओं को "मूल्य से पारित किया गया" था। दूसरी तरफ, यह वही है जो आप उम्मीद करेंगे कि अगर किसी ऑब्जेक्ट हैंडल को फ़ंक्शन पर पास किया गया था, जो वास्तव में होता है। आपका कोड इन दो मामलों के बीच अंतर नहीं करता है।
जोड़ा लेखक EML, स्रोत
मुझे लगता है कि यह सबूत एक गलत व्याख्या है। ऐसा लगता है कि आप संदर्भों को स्वैप करने की कोशिश कर रहे थे। आपको ऑब्जेक्ट्स को असाइन किए जाने में समस्या है। आप संदर्भ को पुन: असाइन कर रहे हैं जो अपरिवर्तनीय है। यह वह मान है जो इसे इंगित करता है जिसे अंदर से बदला जा सकता है। स्वैप का पुनर्वितरण अब ** x गुजर रहा है, जो आपको * x को बदलने की अनुमति देता है। समस्या यह सोचने में है कि $ x = $ y बदल जाएगा जो मूल रूप से $ x को इंगित करता है।
जोड़ा लेखक grantwparks, स्रोत

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

0
जोड़ा
मुझे नहीं लगता कि यह सच है।
जोड़ा लेखक Nick Heiner, स्रोत

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

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

0
जोड़ा

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.

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

0
जोड़ा
पहला पूर्व, ओबीजे के संदर्भ का मूल्य समारोह में पारित किया गया है, नए संदर्भ का उपयोग करके ओबीजे में परिवर्तन एक ही ओबीजे को इंगित करने वाले सभी अन्य संदर्भों को प्रतिबिंबित करेगा। दूसरा एक्स, फिर ओबीजे के संदर्भ का VALUE कार्य को पास कर दिया गया है, फ़ंक्शन संदर्भ के मान को एक नए ओबीजे को इंगित करने के लिए बदल रहा है, पुराना ओब्जे वही रहता है। तीसरा पूर्व, ओबीजे के संदर्भ के मूल्य का संदर्भ कार्य में पारित किया गया है, इस प्रकार फ़ंक्शन में परिवर्तन एक ही ओबीजे पर चल रहा है।
जोड़ा लेखक s-hunter, स्रोत
यह बहुत अच्छी तरह से दिखाता है कि PHP ऑब्जेक्ट कैसे काम करता है।
जोड़ा लेखक Frederik Krautwald, स्रोत

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

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

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

$result=5;
changeValue($result);

echo $result; // $result is 6 here
?>
0
जोड़ा

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

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
0
जोड़ा

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

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.
0
जोड़ा
यह बहिष्कृत है और एक चेतावनी उत्पन्न करता है
जोड़ा लेखक fijiaaron, स्रोत

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

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

0
जोड़ा
"ऑब्जेक्ट्स" PHP5 में मान नहीं हैं और "पास" नहीं हो सकते हैं। सभी चर मान द्वारा पारित किए जाते हैं यदि फ़ंक्शन के पैरामीटर में & नहीं है।
जोड़ा लेखक newacct, स्रोत
@ फ़ेलिक्सगैगन-ग्रेनेयर: फिर, "ऑब्जेक्ट्स" मान नहीं हैं और "पास" नहीं हो सकते हैं। आपके पास PHP5 में "चर" नहीं हो सकता जिसका मूल्य "ऑब्जेक्ट" है, आप केवल एक मान हो सकते हैं जो एक ऑब्जेक्ट संदर्भ है (यानी किसी ऑब्जेक्ट के लिए पॉइंटर)। निस्संदेह आप ऑब्जेक्ट को किसी ऑब्जेक्ट को पॉइंटर पास कर सकते हैं या उस ऑब्जेक्ट को संशोधित कर सकते हैं जो इस तरह के संशोधित करने वाली विधि को कॉल करके इंगित करता है। संदर्भ के साथ पास करने के लिए इसका कोई लेना-देना नहीं है। एक मान कितना प्रकार है और क्या पैरामीटर पास-बाय-वैल्यू / पास-बाय-रेफरेंस स्वतंत्र और ऑर्थोगोनल चीजें हैं।
जोड़ा लेखक newacct, स्रोत
@newacct काफी नहीं है? ऑब्जेक्ट्स कुछ हद तक संदर्भ द्वारा पारित हैं। मुझे लगता है कि मैंने देखा है कि परिभाषा में पैरामीटर के सामने & के साथ परिभाषित नहीं होने पर भी PHP ऑब्जेक्ट्स को संशोधित किया जा सकता है - यदि वे उस दायरे में निहित ऑब्जेक्ट को मानते हैं पैरामीटर के रूप में इसके साथ कार्य प्रभावित नहीं होगा।
जोड़ा लेखक Félix Gagnon-Grenier, स्रोत
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() . "
";

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

आउटपुट:

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

0
जोड़ा

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

0
जोड़ा