PHP
ऑपरेटर्स

परिचय

टिप्पणियों

स्ट्रिंग ऑपरेटर्स (और। =)

केवल दो स्ट्रिंग ऑपरेटर हैं:

• दो तार (डॉट) का समाकलन:

  $a = "a";
  $b = "b";
  $c = $a . $b; // $c => "ab"
  

• संबंधित कार्य (डॉट =):

  $a = "a";
  $a .= "b"; // $a => "ab"
  

मूल असाइनमेंट (=)

$a = "some string";

$a में परिणाम some string मूल्य है।

असाइनमेंट एक्सप्रेशन का परिणाम असाइन किया जा रहा मान है। ध्यान दें कि एक समान चिह्न = तुलना के लिए नहीं है!

$a = 3;
$b = ($a = 5);

निम्नलिखित कार्य करता है:

1. पंक्ति 1 से 3 से $a प्रदान करता $a ।
2. पंक्ति 2 $a 5 से $a प्रदान करती $a । इस अभिव्यक्ति का मान 5 भी है।
3. पंक्ति 2 तब कोष्ठक ( 5 ) से $b में अभिव्यक्ति का परिणाम बताती है।

इस प्रकार: दोनों $a और $b अब मूल्य 5 ।

संयुक्त असाइनमेंट (+ = आदि)

संयुक्त असाइनमेंट ऑपरेटर कुछ चर पर एक ऑपरेशन के लिए एक शॉर्टकट हैं और बाद में उस चर को यह नया मान प्रदान करते हैं।

अंकगणित:

$a = 1;   // basic assignment
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3
$a -= 1; // $a now is (3 - 1) => 2
$a *= 2; // $a now is (2 * 2) => 4
$a /= 2; // $a now is (16 / 2) => 8
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder)

// array +
$arrOne = array(1);
$arrTwo = array(2);
$arrOne += $arrTwo;

एक साथ कई एरर्स को प्रोसेस करना

$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2)

एक स्ट्रिंग का संयुक्त संयोजन और असाइनमेंट:

$a = "a";
$a .= "b"; // $a => "ab"

संयुक्त बाइनरी बिटवाइज़ असाइनमेंट ऑपरेटर:

$a = 0b00101010;  // $a now is 42
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and)
$a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or)
$a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor)
$a >>= 3;         // $a now is (10101000 >> 3) => 00010101 (shift right by 3)
$a <<= 1;         // $a now is (00010101 << 1) => 00101010 (shift left by 1)

संचालक पूर्वता (कोष्ठक के साथ)

जिस क्रम में ऑपरेटरों का मूल्यांकन किया जाता है वह ऑपरेटर पूर्ववर्ती द्वारा निर्धारित किया जाता है (रिमार्क्स अनुभाग भी देखें)।

में

$a = 2 * 3 + 4;

$a को 10 का मान मिलता है क्योंकि 2 * 3 का मूल्यांकन पहले किया जाता है (गुणन में जोड़ की तुलना में अधिक पूर्वता होती है) 6 + 4 उप-परिणाम की उपज, जो 10 के बराबर होती है।

कोष्ठक का उपयोग करके पूर्वता को बदला जा सकता है: में

$a = 2 * (3 + 4);

$a को 14 का मान मिलता है क्योंकि (3 + 4) का मूल्यांकन पहले किया जाता है।

संगति

छोड़ दिया संघ

यदि दो संचालकों की प्राथमिकता समान होती है, तो समूहता समूहन को निर्धारित करती है (रिमार्क्स अनुभाग भी देखें):

$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1

* और % में समान पूर्वता और बाएं समरूपता है। क्योंकि गुणा पहले (बाएं) होता है, इसे समूहीकृत किया जाता है।

$a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4

अब, मापांक ऑपरेटर पहले (बाएं) होता है और इस प्रकार समूहीकृत होता है।

सही सहयोग

$a = 1;
$b = 1;
$a = $b += 1;

दोनों $a और $b अब मान होना 2 क्योंकि $b += 1 वर्गीकृत किया जाता है और फिर परिणाम ( $b है 2 ) को सौंपा गया है $a ।

तुलना संचालक

समानता

बुनियादी समानता परीक्षण के लिए, समान ऑपरेटर == का उपयोग किया जाता है। अधिक व्यापक जांच के लिए, समान ऑपरेटर === उपयोग करें।

समान ऑपरेटर समान ऑपरेटर के समान कार्य करता है, जिसके लिए उसके ऑपरेंड की आवश्यकता समान होती है, लेकिन इसके लिए उन्हें समान डेटा प्रकार की भी आवश्यकता होती है।

उदाहरण के लिए, नीचे का नमूना 'a और b बराबर हैं' प्रदर्शित करेगा, लेकिन 'a और b समान नहीं हैं'।

$a = 4;
$b = '4';
if ($a == $b) {
    echo 'a and b are equal'; // this will be printed
}
if ($a === $b) {
    echo 'a and b are identical'; // this won't be printed
}

समान ऑपरेटर का उपयोग करते समय, संख्यात्मक तार पूर्णांक के लिए डाले जाते हैं।

वस्तुओं की तुलना

=== दो वस्तुओं की तुलना करके जाँचता है कि क्या वे एक ही उदाहरण हैं । इसका मतलब यह है कि new stdClass() === new stdClass() झूठ का समाधान करते हैं, भले ही वे उसी तरह से बनाए गए हों (और बिल्कुल समान मान हों)।

== दो वस्तुओं की तुलना, यदि वे समान ( गहरी बराबर ) हैं, तो पुनरावर्ती जाँच करके करें। इसका मतलब है, $a == $b , यदि $a और $b हैं:

1. उसी वर्ग का
2. गतिशील गुणों सहित समान गुण सेट किए हैं
3. प्रत्येक संपत्ति के लिए $property सेट, $a->property == $b->property सच है (इसलिए पुनरावर्ती रूप से जाँच की गई है)।

अन्य आमतौर पर इस्तेमाल किया ऑपरेटरों

उनमे शामिल है:

1. ग्रेटर थान ( > )
2. लेसन थान ( < )
3. अधिक से अधिक या बराबर ( >= )
4. इससे कम या बराबर ( <= )
5. नहीं के बराबर ( != )
6. समान रूप से नहीं ( !== )

1. इससे बड़ा: $a > $b , रिटर्न true अगर $a के मूल्य की तुलना में अधिक है $b , अन्यथा गलत देता है।

उदाहरण :

var_dump(5 > 2); // prints bool(true)
var_dump(2 > 7); // prints bool(false)

2. कम से कम : $a < $b , अगर $a 's का मूल्य $b से छोटा है, तो true है, अन्यथा झूठे हो जाते हैं।

उदाहरण :

var_dump(5 < 2); // prints bool(false)
var_dump(1 < 10); // prints bool(true)

3. इससे बड़ा या बराबर: $a >= $b , रिटर्न true अगर $a के मूल्य की तुलना में या तो अधिक से अधिक है $b या बराबर $b , अन्यथा रिटर्न false ।

उदाहरण :

var_dump(2 >= 2); // prints bool(true)
var_dump(6 >= 1); // prints bool(true)
var_dump(1 >= 7); // prints bool(false)

4. से छोटी या बराबर: $a <= $b , रिटर्न true अगर $a के मूल्य की तुलना में या तो छोटा होता है $b या बराबर $b , अन्यथा रिटर्न false ।

उदाहरण :

var_dump(5 <= 5); // prints bool(true)
var_dump(5 <= 8); // prints bool(true)
var_dump(9 <= 1); // prints bool(false)

5/6। नहीं के बराबर / पहचान के लिए: समानता पर पहले के उदाहरण को पुनः प्राप्त करने के लिए, नीचे का नमूना 'a और b समान नहीं हैं' प्रदर्शित करेगा, लेकिन 'a और b समान नहीं हैं'।

$a = 4;
$b = '4';
if ($a != $b) {
    echo 'a and b are not equal'; // this won't be printed
}
if ($a !== $b) {
    echo 'a and b are not identical'; // this will be printed
}

स्पेसशिप ऑपरेटर (<=>)

PHP 7 एक नए प्रकार के ऑपरेटर का परिचय देता है, जिसका उपयोग अभिव्यक्तियों की तुलना करने के लिए किया जा सकता है। यह ऑपरेटर -1, 0 या 1 लौटाएगा यदि पहली अभिव्यक्ति दूसरी अभिव्यक्ति की तुलना में कम, बराबर या उससे अधिक है।

// Integers
print (1 <=> 1); // 0
print (1 <=> 2); // -1
print (2 <=> 1); // 1

// Floats
print (1.5 <=> 1.5); // 0
print (1.5 <=> 2.5); // -1
print (2.5 <=> 1.5); // 1
 
// Strings
print ("a" <=> "a"); // 0
print ("a" <=> "b"); // -1
print ("b" <=> "a"); // 1

ऑब्जेक्ट्स तुलनीय नहीं हैं, और ऐसा करने से अपरिभाषित व्यवहार होगा।

यह परिचालक विशेष रूप से तब उपयोगी होता है, जब उपयोगकर्ता-परिभाषित तुलना फ़ंक्शन का उपयोग usort , uasort , या uksort का उपयोग करते हुए करता है। उदाहरण के लिए, वस्तुओं की एक सरणी को उनकी weight संपत्ति द्वारा क्रमबद्ध किया जाना, उदाहरण के लिए, एक अनाम फ़ंक्शन सॉर्टिंग फ़ंक्शन द्वारा अपेक्षित मान वापस करने के लिए <=> का उपयोग कर सकता है।

usort($list, function($a, $b) { return $a->weight <=> $b->weight; });

PHP 5 में इसके लिए अधिक विस्तृत अभिव्यक्ति की आवश्यकता होगी।

usort($list, function($a, $b) {
    return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1);
});

अशक्त सहवर्ती संचालक (??)

Null coalescing एक नया ऑपरेटर है जिसे PHP 7 में पेश किया गया है। यह ऑपरेटर अपने पहले ऑपरेंड को लौटा देता है यदि यह सेट है और NULL नहीं NULL । अन्यथा यह अपने दूसरे ऑपरेंड को वापस कर देगा।

निम्न उदाहरण:

$name = $_POST['name'] ?? 'nobody';

दोनों के बराबर है:

if (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

तथा:

$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 

इस ऑपरेटर को जंजीर में डाला जा सकता है (दाएं-सहकारिता शब्दार्थ के साथ):

$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody';

जो एक समकक्ष है:

if (isset($_GET['name'])) {
    $name = $_GET['name'];
} elseif (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

ध्यान दें:
तार संघनन पर तालमेल ऑपरेटर का उपयोग करते समय कोष्ठक () का उपयोग करना न भूलें

$firstName = "John";
$lastName = "Doe";
echo $firstName ?? "Unknown" . " " . $lastName ?? "";

यह केवल John को आउटपुट देगा, और अगर इसका पहला फर्स्टनाम शून्य है और $ लास्ट नेम Doe यह Unknown Doe उत्पादन करेगा। John Doe का उत्पादन करने के लिए, हमें इस तरह कोष्ठक का उपयोग करना चाहिए।

$firstName = "John";
$lastName = "Doe";
echo ($firstName ?? "Unknown") . " " . ($lastName ?? "");

यह केवल John बजाय John Doe उत्पादन करेगा।

Instof (टाइप ऑपरेटर)

यह जाँचने के लिए कि क्या कोई वस्तु एक निश्चित वर्ग की है, PHP संस्करण 5 के बाद से (बाइनरी) instanceof ऑपरेटर का उपयोग किया जा सकता है।

परीक्षण करने के लिए पहला (बायाँ) पैरामीटर ऑब्जेक्ट है। यदि यह चर वस्तु नहीं है, तो instanceof हमेशा false । यदि निरंतर अभिव्यक्ति का उपयोग किया जाता है, तो एक त्रुटि डाली जाती है।

दूसरे (दाएं) पैरामीटर की तुलना करने वाला वर्ग है। कक्षा को स्वयं कक्षा नाम के रूप में प्रदान किया जा सकता है, एक स्ट्रिंग चर वर्ग नाम (न कि एक स्ट्रिंग स्थिर!) या उस वर्ग का एक ऑब्जेक्ट।

class MyClass {
}

$o1 = new MyClass();
$o2 = new MyClass();
$name = 'MyClass';

// in the cases below, $a gets boolean value true
$a = $o1 instanceof MyClass;
$a = $o1 instanceof $name;
$a = $o1 instanceof $o2;

// counter examples:
$b = 'b';
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed
$a = false instanceof MyClass; // fatal error: constant not allowed
$a = $b instanceof MyClass;    // false ($b is not an object)

instanceof उपयोग यह जांचने के लिए भी किया जा सकता है कि कोई वस्तु किसी वर्ग की है जो किसी अन्य वर्ग का विस्तार करती है या कुछ इंटरफ़ेस को लागू करती है:

interface MyInterface {
}

class MySuperClass implements MyInterface {
}

class MySubClass extends MySuperClass {
}

$o = new MySubClass();

// in the cases below, $a gets boolean value true    
$a = $o instanceof MySubClass;
$a = $o instanceof MySuperClass;
$a = $o instanceof MyInterface;

(चाहे एक वस्तु कुछ वर्ग की नहीं है की जाँच करने के लिए, नहीं ऑपरेटर ! ) का उपयोग किया जा सकता है:

class MyClass {
}

class OtherClass {
}

$o = new MyClass();
$a = !$o instanceof OtherClass; // true

कि नोट कोष्ठकों के आसपास $o instanceof MyClass की जरूरत नहीं है, क्योंकि instanceof की तुलना में अधिक पूर्वता है ! , हालांकि यह कोष्ठक के साथ कोड को बेहतर पठनीय बना सकता है।

चेतावनियां

यदि कोई कक्षा मौजूद नहीं है, तो पंजीकृत ऑटोलैड फ़ंक्शन को कक्षा को परिभाषित करने का प्रयास करने के लिए कहा जाता है (यह दस्तावेज़ीकरण के इस भाग के दायरे के बाहर एक विषय है!)। 5.1.0 से पहले पीएचपी संस्करणों में, instanceof ऑपरेटर भी इन कॉल ट्रिगर करेगा, इस प्रकार वास्तव में वर्ग को परिभाषित (और अगर वर्ग परिभाषित नहीं किया जा सकता है, एक गंभीर त्रुटि घटित होता)। इससे बचने के लिए, एक स्ट्रिंग का उपयोग करें:

// only PHP versions before 5.1.0!
class MyClass {
}

$o = new MyClass();
$a = $o instanceof OtherClass; // OtherClass is not defined!
// if OtherClass can be defined in a registered autoloader, it is actually
// loaded and $a gets boolean value false ($o is not a OtherClass)
// if OtherClass can not be defined in a registered autoloader, a fatal
// error occurs.

$name = 'YetAnotherClass';
$a = $o instanceof $name; // YetAnotherClass is not defined!
// $a simply gets boolean value false, YetAnotherClass remains undefined.

पीएचपी संस्करण 5.1.0 के रूप में, पंजीकृत ऑटोलरोलर्स को इन स्थितियों में अब नहीं बुलाया जाता है।

PHP के पुराने संस्करण (5.0 से पहले)

PHP के पुराने संस्करणों में (5.0 से पहले), is_a फ़ंक्शन का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि ऑब्जेक्ट किसी वर्ग का है। इस फ़ंक्शन को पीएचपी संस्करण 5 में पदावनत किया गया था और पीएचपी संस्करण 5.3.0 में अनिर्धारित किया गया था।

टर्नरी ऑपरेटर (?)

त्रिगुट ऑपरेटर एक इनलाइन के रूप में सोचा जा सकता if बयान। इसमें तीन भाग होते हैं। operator , और दो परिणाम। सिंटैक्स निम्नानुसार है:

$value = <operator> ? <true value> : <false value>

यदि operator का मूल्यांकन true रूप में किया जाता true , तो पहले ब्लॉक में मान लौटाया जाएगा ( <true value> ), दूसरे खंड में मान लौटाया जाएगा ( <false value> )। चूंकि हम अपने टर्नरी ऑपरेटर के परिणाम के लिए $value निर्धारित कर रहे हैं, यह लौटा मूल्य संग्रहीत करेगा।

उदाहरण:

$action = empty($_POST['action']) ? 'default' : $_POST['action'];

$action में स्ट्रिंग 'default' शामिल होगी यदि empty($_POST['action']) सत्य का मूल्यांकन करती है। अन्यथा इसमें $_POST['action'] का मूल्य समाहित होगा।

अभिव्यक्ति (expr1) ? (expr2) : (expr3) करने के लिए मूल्यांकन करता expr2 अगर expr1 मूल्यांकन करने के लिए true है, और expr3 अगर expr1 मूल्यांकन करने के लिए false ।

टर्नरी ऑपरेटर के मध्य भाग को छोड़ना संभव है। expr1 ?: expr3 रिटर्न expr1 अगर expr1 TRUE का मूल्यांकन करता है, और expr3 अन्यथा। ?: अक्सर एल्विस ऑपरेटर के रूप में जाना जाता है।

यह नल Coalescing ऑपरेटर की तरह व्यवहार करता है ?? , इसके अलावा ?? बाएं ऑपरेंड की आवश्यकता होती है, जबकि यह बिल्कुल null ?: बाएं ऑपलैंड को एक बूलियन में हल करने की कोशिश करता है और जाँचता है कि क्या यह बूलियन false समाधान करता है।

उदाहरण:

function setWidth(int $width = 0){
    $_SESSION["width"] = $width ?: getDefaultWidth();
}

इस उदाहरण में, setWidth चौड़ाई सत्र मान को बदलने के लिए एक चौड़ाई पैरामीटर, या डिफ़ॉल्ट 0 को स्वीकार करता है। यदि $width 0 है (यदि $width प्रदान नहीं की गई है), जो बूलियन झूठी का समाधान करेगा, तो इसके बजाय getDefaultWidth() का मान उपयोग किया जाता है। getDefaultWidth() फ़ंक्शन को कॉल नहीं किया जाएगा यदि $width ने बूलियन झूठी का समाधान नहीं किया।

बूलियन के लिए चर के रूपांतरण के बारे में अधिक जानकारी के लिए प्रकार का संदर्भ लें।

वृद्धि (++) और घटते संचालक (-)

चर को क्रमशः ++ या -- साथ 1 से बढ़ा या घटाया जा सकता है। वे या तो पूर्ववर्ती या सफल हो सकते हैं और थोड़े शब्दार्थ में भिन्न हो सकते हैं, जैसा कि नीचे दिखाया गया है।

$i = 1;
echo $i; // Prints 1

// Pre-increment operator increments $i by one, then returns $i
echo ++$i; // Prints 2

// Pre-decrement operator decrements $i by one, then returns $i
echo --$i; // Prints 1

// Post-increment operator returns $i, then increments $i by one
echo $i++; // Prints 1 (but $i value is now 2)

// Post-decrement operator returns $i, then decrements $i by one
echo $i--; // Prints 2 (but $i value is now 1)

वेतन वृद्धि और गिरावट के बारे में अधिक जानकारी आधिकारिक दस्तावेज में पाई जा सकती है।

निष्पादन ऑपरेटर (``)

PHP निष्पादन संचालक में बैकटिक्स (``) शामिल हैं और शेल कमांड चलाने के लिए उपयोग किया जाता है। कमांड का आउटपुट वापस आ जाएगा, और इसलिए, एक चर में संग्रहीत किया जा सकता है।

// List files
$output = `ls`;
echo "<pre>$output</pre>";

ध्यान दें कि निष्पादित ऑपरेटर और shell_exec() एक ही परिणाम देगा।

लॉजिकल ऑपरेटर्स (&& / AND और / / OR)

PHP में, तार्किक AND और OR ऑपरेटर के दो संस्करण हैं।

ध्यान दें कि && और || opererators अधिक है पूर्वता से and और or । नीचे दी गई तालिका देखें:

इस वजह से इसका उपयोग करना सुरक्षित है && और || के बजाय and और or ।

बिटवाइज ऑपरेटर्स

उपसर्ग बिटवाइज़ ऑपरेटर्स

बिटवाइज़ ऑपरेटर तार्किक ऑपरेटरों की तरह होते हैं लेकिन बूलियन मूल्य के बजाय प्रति बिट निष्पादित होते हैं।

// bitwise NOT ~: sets all unset bits and unsets all set bits
printf("%'06b", ~0b110110); // 001001

बिटमास्क-बिटमास्क ऑपरेटर

बिटवाइंड एंड & : बिट को केवल तभी सेट किया जाता है जब वह दोनों ऑपरेंड में सेट हो

printf("%'06b", 0b110101 & 0b011001); // 010001

बिटवाइज OR | : अगर यह या दोनों ऑपरेंड में सेट किया गया है तो थोड़ा सा सेट किया जाता है

printf("%'06b", 0b110101 | 0b011001); // 111101

बिटवाइज़ XOR ^ : एक बिट एक सेट में सेट किया गया है और एक दूसरे ऑपरेंड में सेट नहीं किया गया है, अर्थात केवल अगर वह बिट दो ऑपरेंड में अलग-अलग स्थिति में है

printf("%'06b", 0b110101 ^ 0b011001); // 101100

उदाहरण के लिए बिटमास्क का उपयोग करता है

इन ऑपरेटरों का उपयोग बिटकॉम्स में हेरफेर करने के लिए किया जा सकता है। उदाहरण के लिए:

file_put_contents("file.log", LOCK_EX | FILE_APPEND);

यहाँ, | ऑपरेटर का उपयोग दो बिटमास्क को संयोजित करने के लिए किया जाता है। हालांकि + का एक ही प्रभाव है, | इस बात पर जोर देता है कि आप दो सामान्य स्केलर पूर्णांकों को न जोड़ते हुए बिटमास्क का संयोजन कर रहे हैं।

class Foo{
    const OPTION_A = 1;
    const OPTION_B = 2;
    const OPTION_C = 4;
    const OPTION_A = 8;

    private $options = self::OPTION_A | self::OPTION_C;

    public function toggleOption(int $option){
        $this->options ^= $option;
    }

    public function enable(int $option){
        $this->options |= $option; // enable $option regardless of its original state
    }

    public function disable(int $option){
        $this->options &= ~$option; // disable $option regardless of its original state,
                                    // without affecting other bits
    }

    /** returns whether at least one of the options is enabled */
    public function isOneEnabled(int $options) : bool{
        return $this->options & $option !== 0;
        // Use !== rather than >, because 
        // if $options is about a high bit, we may be handling a negative integer
    }

    /** returns whether all of the options are enabled */
    public function areAllEnabled(int $options) : bool{
        return ($this->options & $options) === $options;
        // note the parentheses; beware the operator precedence
    }
}

यह उदाहरण ( $option हमेशा केवल एक बिट समाहित करता है) का उपयोग करता है:

• ^ ऑपरेटर आसानी से bitmasks टॉगल करने के लिए।
• | ऑपरेटर अपनी मूल स्थिति या अन्य बिट्स की उपेक्षा करते हुए थोड़ा सा सेट करने के लिए
• ~ ऑपरेटर एक पूर्णांक को केवल एक बिट सेट के साथ पूर्णांक में परिवर्तित करने के लिए केवल एक बिट सेट के साथ परिवर्तित करने के लिए नहीं
• & ऑपरेटर एक सा अनसेट करने के लिए, के इन गुणों का उपयोग कर & :
  • चूँकि एक सेट बिट के साथ &= कुछ भी नहीं करेगा (1 & 1) === 1 , (0 & 1) === 0 ), पूर्णांक के साथ ऐसा करने से &= केवल एक बिट सेट नहीं होने से वह परेशान नहीं होगा , अन्य बिट्स को प्रभावित नहीं कर रहा है।
  • &= एक परेशान बिट के साथ उस बिट को परेशान करेगा ( (1 & 0) === 0 , (0 & 0) === 0 )
• एक और बिटमास्क के साथ & ऑपरेटर का उपयोग करके उस बिटमास्क में सेट नहीं किए गए अन्य सभी बिट्स को फ़िल्टर किया जाएगा।
  • यदि आउटपुट में कोई बिट सेट है, तो इसका मतलब है कि विकल्पों में से कोई भी सक्षम है।
  • यदि आउटपुट में बिटमस्क सेट के सभी बिट्स हैं, तो इसका मतलब है कि बिटमास्क में सभी विकल्प सक्षम हैं।

याद रखिए कि इन तुलना ऑपरेटरों: ( < > <= >= == === != !== <> <=> ) इन bitmask-bitmask ऑपरेटरों की तुलना में अधिक पूर्वता है: ( | ^ & )। जैसा कि बिटवाइज़ परिणाम अक्सर इन तुलना ऑपरेटरों का उपयोग करके किया जाता है, इसके बारे में जागरूक होने के लिए यह एक सामान्य नुकसान है।

बिट-शिफ्टिंग ऑपरेटर

बिटवाइज़ लेफ्ट शिफ्ट << : सभी बिट्स को बाईं ओर (अधिक महत्वपूर्ण) शिफ्ट में दी गई संख्याओं द्वारा स्थानांतरित करें और बिट्स को अंतर आकार से अधिक छोड़ दें

<< $x उच्चतम $x बिट्स को परेशान करने के बराबर है और $x th की शक्ति 2 से गुणा कर रहा है

printf("%'08b", 0b00001011<< 2); // 00101100

assert(PHP_INT_SIZE === 4); // a 32-bit system
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF

बिटवाइज़ राइट शिफ्ट >> : सबसे कम शिफ्ट को छोड़ें और शेष बिट्स को दाईं ओर शिफ्ट करें (कम महत्वपूर्ण)

>> $x 2 की $x वें शक्ति द्वारा विभाजित करने के बराबर है और गैर-पूर्णांक भाग को छोड़ देता है

printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF

बिट शिफ्टिंग का उदाहरण उपयोग:

16 से फास्ट डिवीजन (तुलना में बेहतर प्रदर्शन /= 16 )

$x >>= 4;

32-बिट सिस्टम पर, यह पूर्णांक में सभी बिट्स को अलग करता है, मान को 0 पर सेट करता है। 64-बिट सिस्टम पर, यह सबसे महत्वपूर्ण 32 बिट्स को अनसेट करता है और कम से कम रखता है

$x = $x << 32 >> 32;

$x & 0xFFFFFFFF 32 $x & 0xFFFFFFFF बराबर महत्वपूर्ण 32 बिट्स

नोट: इस उदाहरण में, printf("%'06b") का उपयोग किया जाता है। यह 6 बाइनरी अंकों में मूल्य को आउटपुट करता है।

ऑब्जेक्ट और क्लास ऑपरेटर्स

ऑब्जेक्ट ऑपरेटर ( -> ) और क्लास ऑपरेटर ( :: :) का उपयोग करके ऑब्जेक्ट या कक्षाओं के सदस्यों तक पहुँचा जा सकता है।

class MyClass {
    public $a = 1;
    public static $b = 2;
    const C = 3;
    public function d() { return 4; }
    public static function e() { return 5; }
}

$object = new MyClass();
var_dump($object->a);   // int(1)
var_dump($object::$b);  // int(2)
var_dump($object::C);   // int(3)
var_dump(MyClass::$b);  // int(2)
var_dump(MyClass::C);   // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass";
var_dump($classname::e()); // also works! int(5)

ध्यान दें कि वस्तु ऑपरेटर के बाद, $ लिखा नहीं किया जाना चाहिए ( $object->a के बजाय $object->$a )। क्लास ऑपरेटर के लिए, यह मामला नहीं है और $ आवश्यक है। वर्ग में एक निरंतर परिभाषित के लिए, $ का उपयोग कभी नहीं किया जाता है।

यह भी ध्यान दें कि var_dump(MyClass::d()); केवल तभी अनुमति दी जाती है यदि फ़ंक्शन d() ऑब्जेक्ट को संदर्भित नहीं करता है:

class MyClass {
    private $a = 1;
    public function d() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump(MyClass::d());   // Error!

यह 'PHP घातक त्रुटि: अनकवर्ड एरर: $ का उपयोग तब करता है जब ऑब्जेक्ट संदर्भ में नहीं'

इन संचालकों ने संबद्धता छोड़ दी है , जिसका उपयोग 'जंजीर' के लिए किया जा सकता है:

class MyClass {
    private $a = 1;
    
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    
    public function get() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump($object->add(4)->get());  // int(5)

इन संचालकों की सर्वोच्च प्राथमिकता होती है (वे मैनुअल में भी उल्लेखित नहीं हैं), यहां तक कि उस clone भी उच्चतर। इस प्रकार:

class MyClass {
    private $a = 0;
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    public function get() {
        return $this->a;
    }
}

$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

ऑब्जेक्ट क्लोन करने से पहले $o1 का मूल्य जोड़ा जाता है!

ध्यान दें कि वरीयता को प्रभावित करने के लिए कोष्ठक का उपयोग PHP संस्करण 5 और पुराने (यह PHP 7 में करता है) में काम नहीं किया है:

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2);  // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7