संदर्भ - PHP में इस प्रतीक का क्या अर्थ है?


Answers

बिटवाई ऑपरेटर

थोड़ा सा क्या है थोड़ा सा 1 या 0 का प्रतिनिधित्व है। मूल रूप से बंद (0) और चालू (1)

बाइट क्या है? एक बाइट 8 बिट्स से बना होता है और बाइट का उच्चतम मूल्य 255 होता है, जिसका अर्थ यह होगा कि प्रत्येक बिट सेट हो। हम देखेंगे कि बाइट का अधिकतम मूल्य 255 क्यों है।

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

1 बाइट का यह प्रतिनिधित्व

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 बाइट)

बेहतर समझने के लिए कुछ उदाहरण

"और" ऑपरेटर: &

$a =  9;
$b = 10;
echo $a & $b;

यह संख्या 8 का उत्पादन करेगा क्यों? खैर देखते हैं कि हमारे टेबल उदाहरण का उपयोग करें।

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

तो आप तालिका से देख सकते हैं कि वे एक साथ साझा करते हैं केवल 8 बिट है।

दूसरा उदाहरण

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

दो साझा बिट्स 32 और 4 हैं, जो एक साथ जोड़े जाने पर 36 लौटते हैं।

"या" ऑपरेटर: |

$a =  9;
$b = 10;
echo $a | $b;

यह संख्या 11 आउटपुट होगा क्यों?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

आप देखेंगे कि हमारे पास 8 बिट्स सेट हैं, 8, 2 और 1 कॉलम में। उन्हें जोड़ें: 8 + 2 + 1 = 11।

Question

यह क्या है?

यह प्रश्नों का एक संग्रह है जो हर समय और फिर PHP में वाक्यविन्यास के बारे में आता है। यह एक सामुदायिक विकी भी है, इसलिए इस सूची को बनाए रखने में सभी को भाग लेने के लिए आमंत्रित किया जाता है।

ऐसा क्यों है?

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

¹ नोट: जनवरी 2013 से, स्टैक ओवरफ़्लो विशेष वर्णों का समर्थन करता है । उद्धरणों से बस खोज शब्दों को घेरे, उदाहरण के लिए [php] "==" vs "==="

मुझे यहाँ क्या करना चाहिए?

अगर आपको किसी के द्वारा यहां बताया गया है क्योंकि आपने ऐसा प्रश्न पूछा है, तो कृपया नीचे दिए गए विशेष वाक्यविन्यास को ढूंढें। लिंक किए गए प्रश्नों के साथ PHP मैन्युअल में लिंक किए गए पृष्ठ शायद आपके प्रश्न का उत्तर देंगे। यदि ऐसा है, तो आपको उत्तर को ऊपर उठाने के लिए प्रोत्साहित किया जाता है। यह सूची दूसरों द्वारा प्रदान की गई सहायता के विकल्प के रूप में नहीं है।

सूचि

यदि आपका विशेष टोकन नीचे सूचीबद्ध नहीं है, तो आप इसे पार्सर टोकन की सूची में पा सकते हैं।

& बिटवाई ऑपरेटर या References

=& References

&= बिटवाई ऑपरेटर

&& लॉजिकल ऑपरेटर्स

% अंकगणितीय ऑपरेटरों

!! लॉजिकल ऑपरेटर्स

@ त्रुटि नियंत्रण ऑपरेटर

?: टर्नरी ऑपरेटर

?? नल कोलेसेस ऑपरेटर (PHP 7 के बाद से)

: नियंत्रण संरचनाओं , टर्नरी ऑपरेटर के लिए वैकल्पिक वाक्यविन्यास

:: स्कोप रेज़ोल्यूशन ऑपरेटर

\ Namespaces

-> कक्षाएं और वस्तुओं

=> Arrays

^ बिटवाई ऑपरेटर्स

>> बिटवाई ऑपरेटर

<< बिटवाई ऑपरेटर

<<< हेरेडोक या नाओडोक

= असाइनमेंट ऑपरेटर

== तुलना ऑपरेटर

=== तुलना ऑपरेटर

!== तुलना ऑपरेटर

!= तुलना ऑपरेटर

<> तुलना ऑपरेटर

<=> तुलना ऑपरेटर (PHP 7.0 के बाद से)

  • स्पेसशिप (तीन तरह की तुलना) ऑपरेटर

| बिटवाई ऑपरेटर

|| लॉजिकल ऑपरेटर्स

~ बिटवाई ऑपरेटर

+ अंकगणितीय ऑपरेटर , ऐरे ऑपरेटर

+= और -= असाइनमेंट ऑपरेटर

++ और -- बढ़ते / घटकों को कम करना

.= असाइनमेंट ऑपरेटर

. स्ट्रिंग ऑपरेटर

, फ़ंक्शन तर्क

, परिवर्तनीय घोषणाएं

$$ परिवर्तनीय चर

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

<?= लघु खुले टैग

[] Arrays (PHP 5.4 के बाद से लघु वाक्यविन्यास)

<? खुले और समापन टैग

... तर्क अनपॅकिंग (PHP 5.6 के बाद से)

** Exponentiation (PHP 5.6 के बाद से)

# वन-लाइन शेल-स्टाइल टिप्पणी




प्रश्न :

PHP में "&" का अर्थ क्या है?

PHP "और" ऑपरेटर

एक बार जब हम इसका इस्तेमाल करते हैं तो जीवन को और अधिक आसान बनाता है .. (ध्यान से नीचे उदाहरण देखें)

और आमतौर पर $ बिट्स और $ बी दोनों में सेट बिट्स सेट की जाती हैं।

क्या आपने यह भी देखा है कि ये कॉल कैसे काम करती हैं?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

तो उपरोक्त सभी के पीछे bitwise ऑपरेटर और बिट्स का खेल है।

इनमें से एक उपयोगी मामला नीचे की तरह आसान कॉन्फ़िगरेशन है, इसलिए एक एकल पूर्णांक फ़ील्ड आपके लिए हजारों combos स्टोर कर सकता है।

अधिकांश लोगों ने पहले ही दस्तावेज़ों को पढ़ लिया है लेकिन इन बिटवाई ऑपरेटरों के वास्तविक विश्व उपयोग मामले को राहत नहीं दी है।

उदाहरण है कि आप प्यार करेंगे

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird



PHP में ऑपरेटरों का एक सिंहावलोकन:

लॉजिकल ऑपरेटर्स:

  • $ a && $ b: सत्य अगर दोनों $ a और $ b सत्य हैं।
  • $ ए || $ बी: सही अगर या तो $ एक या $ बी सत्य है।
  • $ एक xor $ b: सत्य अगर या तो $ एक या $ बी सत्य है, लेकिन दोनों नहीं।
  • ! $ ए: सही अगर $ एक सत्य नहीं है।
  • $ ए और $ बी: सही अगर दोनों $ और $ बी सत्य हैं।
  • $ ए या $ बी: सही अगर कोई $ या $ बी सत्य है।

तुलना ऑपरेटर:

  • $ a == $ b: सही अगर $ j टाइपिंग के बाद $ b के बराबर है।
  • $ a === $ b: सही अगर $ एक $ बी के बराबर है, और वे एक ही प्रकार के हैं।
  • $ ए! = $ बी: सही अगर $ j टाइपिंग के बाद $ b के बराबर नहीं है।
  • $ a <> $ b: सही अगर $ j टाइपिंग के बाद $ b के बराबर नहीं है।
  • $ ए! == $ बी: सही अगर $ ए $ बी के बराबर नहीं है, या वे एक ही प्रकार के नहीं हैं।
  • $ a <$ b : सही अगर $ ए कड़ाई से $ बी से कम है।
  • $ ए> $ बी : सही अगर $ ए कड़ाई से $ बी से अधिक है।
  • $ a <= $ b : सही अगर $ एक $ बी से कम या बराबर है।
  • $ a> = $ b : सही अगर $ एक $ बी से अधिक या बराबर है।
  • $ a <=> $ b : शून्य से कम, बराबर, या शून्य से अधिक एक पूर्णांक क्रमशः $ बी से कम, बराबर या उससे अधिक है। PHP 7 के रूप में उपलब्ध है।
  • $ ए? $ बी: $ सी : अगर $ एक वापसी $ बी और $ सी ( टर्नरी ऑपरेटर ) वापस
  • $ एक ?? $ सी : $ ए के समान? $ ए: $ सी ( शून्य कोलेसिंग ऑपरेटर - PHP> = 7 की आवश्यकता है)

अंकगणितीय आपरेटर:

  • - $ ए : $ ए के विपरीत।
  • $ ए + $ बी : $ ए और $ बी का योग।
  • $ ए - $ बी : $ ए और $ बी का अंतर।
  • $ ए * $ बी : $ ए और $ बी का उत्पाद।
  • $ ए / $ बी : $ ए और $ बी का कोटिएंट।
  • $ एक% $ बी : $ बी के विभाजित $ के शेष।
  • $ एक ** $ बी : $ b'th पावर को $ एक बढ़ाने का परिणाम (PHP 5.6 में पेश किया गया)

बढ़ते / घटाने वाले ऑपरेटरों:

  • ++ $ ए : $ एक से बढ़ता है, फिर $ ए देता है।
  • $ ए ++ : $ एक देता है, फिर $ एक को बढ़ाता है।
  • - $ ए : एक करके $ एक घटाता है, फिर $ ए देता है।
  • $ a-- : $ एक देता है, फिर $ एक को कम करता है।

बिटवाई ऑपरेटर:

  • $ ए और $ बी : बिट्स जो $ ए और $ बी दोनों में सेट हैं सेट हैं।
  • $ ए | $ बी : $ एक या $ बी में सेट बिट्स सेट हैं।
  • $ a ^ $ b : बिट्स जो $ a या $ b में सेट हैं लेकिन दोनों सेट नहीं हैं।
  • ~ $ ए : बिट्स जो $ एक में सेट हैं सेट नहीं हैं, और इसके विपरीत।
  • $ a << $ b : बाईं ओर $ $ b चरणों के बिट्स को Shift करें (प्रत्येक चरण का अर्थ है "दो से गुणा करें")
  • $ ए >> $ बी : दाईं ओर $ $ बी चरणों के बिट्स को शिफ्ट करें (प्रत्येक चरण का मतलब है "दो से विभाजित करें")

स्ट्रिंग ऑपरेटर:

  • $ ए $ बी : $ ए और $ बी का संतोष।

ऐरे ऑपरेटर:

  • $ ए + $ बी : $ ए और $ बी का संघ।
  • $ a == $ b : सही अगर $ a और $ b में एक ही कुंजी / मान जोड़े हैं।
  • $ a === $ b : सही अगर $ a और $ b के समान क्रम / समान प्रकार के समान कुंजी / मान जोड़े हैं।
  • $ ए! = $ बी : सही अगर $ ए $ बी के बराबर नहीं है।
  • $ a <> $ b : सत्य अगर $ ए $ बी के बराबर नहीं है।
  • $ ए! == $ बी : सही अगर $ ए $ बी के समान नहीं है।

असाइनमेंट ऑपरेटर:

  • $ ए = $ बी : $ बी का मूल्य $ ए को सौंपा गया है
  • $ ए + = $ बी : $ ए = $ ए + $ बी के समान
  • $ ए - = $ बी : $ ए = $ ए - $ बी के समान
  • $ ए * = $ बी : $ ए = $ ए * $ बी के समान
  • $ ए / = $ बी : $ ए = $ ए / $ बी के समान
  • $ एक% = $ बी : $ = $ एक% $ बी के समान
  • $ एक ** = $ बी : $ = $ एक ** $ b के समान
  • $ ए। = $ बी : $ ए = $ ए के समान। $ ख
  • $ ए और = $ बी : $ एक = $ ए और $ बी के समान
  • $ ए | = $ बी : $ एक = $ ए के समान $ ख
  • $ a ^ = $ b : $ a = $ a ^ $ b के समान
  • $ a << = $ b : $ a = $ a << $ b के समान
  • $ ए >> = $ बी : $ एक = $ एक >> $ बी के समान

ध्यान दें

and ऑपरेटर और ऑपरेटर असाइनमेंट ऑपरेटर = तुलना में कम प्राथमिकता है।

इसका मतलब है कि $a = true and false; बराबर है ($a = true) and false

ज्यादातर मामलों में आप शायद && और || का उपयोग करना चाहेंगे , जो सी, जावा या जावास्क्रिप्ट जैसी भाषाओं से ज्ञात तरीके से व्यवहार करता है।







नल Coalesce ऑपरेटर "??" (PHP 7 में जोड़ा गया)

एक ऑपरेटर के लिए सबसे आकर्षक नाम नहीं है, लेकिन PHP 7 बल्कि आसान काम को लाता है इसलिए मैंने सोचा कि मैं एक उदाहरण साझा करूंगा।

PHP 5 में, हमारे पास पहले से ही एक टर्नरी ऑपरेटर है, जो एक मान का परीक्षण करता है, और उसके बाद दूसरा तत्व देता है यदि यह सत्य लौटाता है और तीसरा यदि यह नहीं करता है:

echo $count ? $count : 10; // outputs 10

इसके लिए एक शॉर्टेंड भी है जो आपको दूसरे तत्व को छोड़ने की इजाजत देता है यदि यह पहले जैसा ही है: echo $ count?: 10; // 10 आउटपुट भी

PHP 7 में हम अतिरिक्त रूप से प्राप्त करते हैं ?? operator which rather than indicating extreme confusion which is how I would usually use two question marks together instead allows us to chain together a string of values. Reading from left to right, the first value which exists and is not null is the value that will be returned.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

This construct is useful for giving priority to one or more values coming perhaps from user input or existing configuration, and safely falling back on a given default if that configuration is missing. It's kind of a small feature but it's one that I know I'll be using as soon as my applications upgrade to PHP 7.




नल coalescing ऑपरेटर (??)

isset() के साथ संयोजन में एक टर्नरी ऑपरेटर का उपयोग करने की आवश्यकता के सामान्य मामले के लिए यह ऑपरेटर PHP 7.0 में जोड़ा गया है। यदि यह अस्तित्व में है और यह पूर्ण नहीं है तो यह अपना पहला ऑपरेंड देता NULL ; अन्यथा यह अपना दूसरा ऑपरेंड देता है।

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>



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

PHP 7 में जोड़ा गया

स्पेसशिप ऑपरेटर <=> PHP 7 में जोड़ा गया नवीनतम तुलना ऑपरेटर है। यह समानता वाले ऑपरेटरों ( == != , === !== ) के समान प्राथमिकता वाला गैर-सहयोगी बाइनरी ऑपरेटर है। यह ऑपरेटर बाएं हाथ और दाएं हाथ के संचालन के बीच सरल तीन-तरफा तुलना करने की अनुमति देता है।

ऑपरेटर के परिणामस्वरूप पूर्णांक अभिव्यक्ति होती है:

  • 0 जब दोनों ऑपरेंड बराबर होते हैं
  • 0 से कम जब बाएं हाथ के ऑपरेंड दाएं हाथ के ऑपरेंड से कम है
  • 0 से बड़ा जब बाएं हाथ का ऑपरेंड दाएं हाथ के ऑपरेंड से बड़ा होता है

जैसे

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

इस ऑपरेटर का उपयोग करने का एक अच्छा व्यावहारिक अनुप्रयोग तुलनात्मक प्रकार कॉलबैक में होगा जो कि दो मानों के बीच तीन-तरफा तुलना के आधार पर शून्य, नकारात्मक, या सकारात्मक पूर्णांक लौटने की उम्मीद है। usort को पारित तुलना समारोह एक ऐसा उदाहरण है।

PHP 7 से पहले आप लिखेंगे ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

चूंकि PHP 7 आप लिख सकते हैं ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});



{} घुंघराले ब्रेसिज़

और अंतिम पोस्ट के बारे में कुछ शब्द

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works



syntax    name              description 
x == y    Equality          True if x and y have the same key/value pairs
x != y    Inequality        True if x is not equal to y
x === y   Identity          True if x and y have the same key/value pairs in 
                              the same order and of the same types
x !== y   Non-identity      True if x is not identical to y
++ x      Pre-increment     Increments x by one, then returns x
x ++      Post-increment    Returns x, then increments x by one
-- x      Pre-decrement     Decrements x by one, then returns x
x --      Post-decrement    Returns x, then decrements x by one
x and y   And               True if both x and y are true x=6 y=3 
                              (x < 10 and y > 1) returns true
x && y    And               True if both x and y are true x=6 y=3 
                              (x < 10 && y > 1) returns true
a . b     Concatenation     Concatenate two strings: "Hi" . "Ha"