PHP में "= &" और "&=" ऑपरेटरों का क्या अर्थ है?




operators (2)

$a &= $b $a = $a & $b जो bitwise-and ऑपरेटर है।

$a =& $b reference रूप में $a =& $b असाइन करता है।

PHP में "= &" / "& =" ऑपरेटरों का क्या अर्थ है? मैं उनके बारे में जानकारी कहां पढ़ सकता हूं?

Google खोजना मदद नहीं करता है।


= &

$a =& $b लिए उपनाम में $a बदल जाता है। यदि $a का मान या संदर्भ बदल दिया गया है, तो $b का मान या संदर्भ तदनुसार बदल जाएगा।

ऑब्जेक्ट्स की बात आने पर यह "एक ही स्थान पर इंगित करने" दोनों से भिन्न होता है: मैं $c = $d = new AnObject( ) कर सकता हूं, और दोनों चर एक ही स्थान पर इंगित करेंगे; हालांकि, बदल रहा है जहां एक बिंदु अन्य बिंदुओं को नहीं बदलेगा। यही है, $c = null $d = null नहीं करेगा। $a =& $b के मामले में, हालांकि, $a = null $b = null

नोट: आधिकारिक तौर पर, उपनाम वास्तव में संदर्भ कहा जाता है। आधिकारिक शब्दावली एक गलत नामक है और निश्चित रूप से संदिग्ध है, इसलिए मैंने इसके बजाय "उपनाम" शब्द का उपयोग करने का विकल्प चुना है। प्रलेखन के लिए, php.net देखें।

उपयोग और प्रभाव

स्केलर मानों के साथ, =& किसी ऑब्जेक्ट में मान को लपेटने जैसा है, ताकि आप कई चर के बीच सार्वभौमिक रूप से मूल्य बदल सकें। आमतौर पर संदर्भ (ऑब्जेक्ट्स) द्वारा पारित प्रकारों के साथ, =& संदर्भ के संदर्भ प्रदान करता है।

मैं =& जब मैं सहयोगी सरणी के साथ काम कर रहा हूँ का उपयोग करते हैं। $foo['bar']['foobar'] कई बार फिर से लिखने की बजाय, मैं उपनाम बना सकता हूं: $foobar =& $foo['bar']['foobar'] । यह तब भी काम करता है जब सूचकांक अभी तक मौजूद नहीं है। अगर $foo['bar']['foobar'] मौजूद नहीं है, तो जारी isset($foobar) गलत होगा। यह एक सादे पुराने चर का उपयोग करने से बेहतर है, क्योंकि मैं त्रुटि को ट्रिगर किए बिना कुंजी के अस्तित्व के परीक्षण के पहले उपनाम बना सकता हूं।

जब आप पूरा कर लें तो उपनाम को अनसेट करें ( unset($foobar) ) उपनाम। अन्यथा, यदि आप बाद में परिवर्तनीय नाम का पुन: उपयोग करते हैं, तो आप जो भी उपनाम इंगित कर रहे थे उसे ओवरराइट करना समाप्त कर देंगे।

आप अन्य तरीकों से उपनाम का भी उपयोग कर सकते हैं - वे असाइनमेंट तक ही सीमित नहीं हैं। वे साथ काम करते हैं:

  • foreach loops: foreach ($a as &$b) $b को असाइन करने से $b में इसी मान को ओवरराइट कर दिया जाएगा। जब आप पूरा कर लेंगे तो $b अनसेट करें, या आप अजीब समस्याओं में भाग लेंगे!
  • फ़ंक्शन / विधि पैरामीटर: function foobar(&$a) फ़ोबबार के भीतर $a को असाइन करने से कॉलर को जो भी वैरिएबल $a रूप में पास किया जाएगा, बदल जाएगा।
  • फ़ंक्शन / विधि वापसी मूल्य: function &foobar() जो कुछ भी वापस किया जाता है उसे कॉलर द्वारा संशोधित किया जा सकता है; यह उपनाम के आसपास गुजरने के लिए उपयोगी है। दुरुपयोग करना भी आसान है।
  • सरणी: $a = array(&$b) $a[0] कोई भी परिवर्तन अब $b असाइनमेंट सहित प्रभावित करेगा।
  • call_user_func_array: call_user_func('foobar', array(&$a)) मान लें कि foobar एक एकल उपनाम पैरामीटर लेता है, foobar अब $a संशोधित कर सकता $a । यह आपको call_user_func_array का उपयोग करके उपनाम पैरामीटर के साथ फ़ंक्शंस / विधियों को कॉल करने की अनुमति देता है।

उदाहरण

Scalars

$original = 1;
$copy = $original;
$reference =& $original;
// All three variables == 1.

$reference = 2;
// $original == 2, $reference == 2, $copy == 1

$original = 3;
// $original == 3, $reference == 3, $copy == 1

$copy = 4;
// $original == 3, $reference == 3, $copy == 4

वस्तुओं

#!/usr/bin/env php
<?php
class Object
{
        private $properties;

        public function __construct(array $properties = array())
        {
                $this->properties = $properties;
        }

        public function __isset($key)
        {
                return isset($this->properties[$key]);
        }

        public function __unset($key)
        {
                unset($this->properties[$key]);
        }

        public function __get($key)
        {
                return isset($this->$key) ? $this->properties[$key] : null;
        }

        public function __set($key, $value)
        {
                $this->properties[$key] = $value;
        }

        public function __toString()
        {
                return print_r($this->properties, true);
        }
}

function print_vars()
{
        global $original, $ref, $refref;

        echo
                '$original: ', $original,
                '$ref: ', $ref,
                '$refref: ', $refref,
                PHP_EOL;
}

$original = new Object(array('a' => 1, 'b' => 2, 'c' => 3));
$ref = $original;
$refref =& $original;
print_vars();
/*
$original: Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)
$ref: Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)
$refref: Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)
*/

$original->a = 'duck';
$ref->b = 'moose';
$refref->c = 'cow';
print_vars();
/*
$original: Array
(
    [a] => duck
    [b] => moose
    [c] => cow
)
$ref: Array
(
    [a] => duck
    [b] => moose
    [c] => cow
)
$refref: Array
(
    [a] => duck
    [b] => moose
    [c] => cow
)
*/

// This carries over to $refref, but not $ref.
$original = new Object(array('x' => 1, 'y' => 2, 'z' => 3));
print_vars();
/*
$original: Array
(
    [x] => 1
    [y] => 2
    [z] => 3
)
$ref: Array
(
    [a] => duck
    [b] => moose
    [c] => cow
)
$refref: Array
(
    [x] => 1
    [y] => 2
    [z] => 3
)
 */

// This does *not* carry over to $original or $ref.
$ref = new Object(array('o' => 42, 'm' => 123, 'n' => 1337));
print_vars();
/*
$original: Array
(
    [x] => 1
    [y] => 2
    [z] => 3
)
$ref: Array
(
    [o] => 42
    [m] => 123
    [n] => 1337
)
$refref: Array
(
    [x] => 1
    [y] => 2
    [z] => 3
)
*/

// This *does* carry over to $original, but not $ref.
$refref = new Object(array('alpha' => 10, 'beta' => 20, 'gamma' => 30));
print_vars();
/*
$original: Array
(
    [alpha] => 10
    [beta] => 20
    [gamma] => 30
)
$ref: Array
(
    [o] => 42
    [m] => 123
    [n] => 1337
)
$refref: Array
(
    [alpha] => 10
    [beta] => 20
    [gamma] => 30
)
*/
?>

और =

&= से संबंधित नहीं है। यह असाइनमेंट ऑपरेशंस के एक सेट से आता है। यहां कुछ ही हैं:

  • +=
  • -=
  • *=
  • /=

यहाँ प्रवृत्ति देखें?

बाइनरी अंकगणितीय ऑपरेटरों में आमतौर पर असाइनमेंट समकक्ष होते हैं। मान लें कि @ एक अंकगणितीय ऑपरेटर थे (यह लेखन के रूप में नहीं है) जैसे कि $a @ $b आमतौर पर एक संख्या उत्पन्न करता है जब $a और $b संख्याएं होती हैं। (सोचो: जोड़, गुणा, विभाजन, आदि) आपको इस तरह कुछ करने की कितनी बार आवश्यकता है?

$a = $a @ $b;

बहुत बार। क्या यह $a दोहराने के लिए थोड़ा अनावश्यक प्रतीत नहीं होता $a ? PHP सहित कई भाषाएं, इसे असाइनमेंट ऑपरेटरों की एक सरणी के साथ हल करें:

$a @= $b;

बहुत आसान, और इस संकेत के आदी प्रोग्रामर के लिए, शायद एक नज़र में अधिक संक्षिप्त और वर्णनात्मक। (मुझे निश्चित रूप से पढ़ने में आसान लगता है, क्योंकि मैं इसका उपयोग करता हूं।) तो एक चर को दोगुना करने के लिए:

$a *= 2;

त्वरित, आसान, और अपेक्षाकृत वर्णनात्मक। PHP सहित कुछ भाषाएं, अतिरिक्त सुविधा या दो के लिए अंकगणितीय से परे इस सुविधा को बढ़ाती हैं। विशेष रूप से:

$a = $a . 'Appended text';
// Is the same as:
$a .= 'Appended text';

बहुत उपयोगी।

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

इसका मतलब है कि $a &= $b $a = $a & $b जैसा ही है।





operators