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




8 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।

php operators symbols php-5.3

यह क्या है?

यह प्रश्नों का एक संग्रह है जो हर समय और फिर 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 के बाद से)

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




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"



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

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



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 : सत्य अगर $ ए $ बी के बराबर नहीं है।
  • $ ए! == $ बी : सही अगर $ ए $ बी के समान नहीं है।

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

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

ध्यान दें

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

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

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




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

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

$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



नल 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 में "&" का अर्थ क्या है?

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



==परिवर्तनीय डेटा-प्रकार पर विचार किए बिना चेक समानता के लिए प्रयोग किया जाता है

===वैरिएबल वैल्यू * और ** डेटा-टाइप दोनों के लिए चेक समानता के लिए प्रयोग किया जाता है

उदाहरण

$a = 5

  1. if ($a == 5) - सच का मूल्यांकन करेंगे

  2. if ($a == '5') - सत्य का मूल्यांकन करेगा, क्योंकि यह दोनों मूल्य की तुलना करते समय PHP आंतरिक रूप से उस स्ट्रिंग मान को पूर्णांक में परिवर्तित करता है और फिर दोनों मानों की तुलना करता है

  3. if ($a === 5) - सच का मूल्यांकन करेंगे

  4. if ($a === '5') - गलत का मूल्यांकन करेगा, क्योंकि मान 5 है, लेकिन यह मान 5 पूर्णांक नहीं है।




Related