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

4475

यह क्या है?

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

ऐसा क्यों है?

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

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

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

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

सूचि

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

& बिटवाइज ऑपरेटर या संदर्भ

=& संदर्भ

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

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

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

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

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

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

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

?string ?int ?array ?bool ?float अशक्त वापसी प्रकार की घोषणा (PHP 7.1 के बाद से)

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

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

\ नेमस्पेस

-> वर्ग और वस्तुएँ

=> Arrays

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

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

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

<<< Heredoc या Nowdoc

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

== तुलना संचालक

=== तुलना संचालक

!== तुलना संचालक

!= तुलना संचालक

<> तुलना संचालक

<=> तुलना संचालक (PHP 7.0 के बाद से)

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

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

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

+ अरिथमेटिक ऑपरेटर्स , ऐरे ऑपरेटर्स

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

++और -- इंक्रीमेंटिंग / डेक्रिमेंटिंग ऑपरेटर्स

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

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

, कार्य तर्क

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

$$ चर चर

` निष्पादन संचालक

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

[] Arrays (PHP 5.4 से छोटा सिंटैक्स)

<? खुलने और बंद होने के टैग

... तर्क unpacking (PHP 5.6 के बाद से)

** प्रतिपादक (PHP 5.6 के बाद से)

# एक-पंक्ति शेल-शैली की टिप्पणी

:? अशक्त वापसी प्रकार

php  arguments  operators  symbols 
— गॉर्डन
स्रोत
36
मुझे पता है कि यह कड़ाई से PHP नहीं है, लेकिन phpDocumentor टिप्पणी वाक्य रचना के लिए phpdoc.org के लिंक सहित क्या है , जो आमतौर पर उपयोग किया जाता है और इसे खोजना भी असंभव है /**?
— माइक
8
क्या मैं चौकोर ब्रैकेट और घुंघराले ब्रैकेट सुझा सकता हूं?
— अंजुअल
124
मैं इस समस्या में बहुत भाग गया (विशेष वर्णों की खोज करने में सक्षम नहीं), यही वजह है कि मैंने SymbolHound को एक खोज इंजन बनाया, जो विशेष वर्णों की उपेक्षा नहीं करता है। मैंने इसे StackApps पर भी पोस्ट किया ।
— dncrane
1
खैर, हेडिंग से यह क्यों है? मुझे लगता है कि ऐसा लगता है क्योंकि "मुख्य विचार स्टैक ओवरफ्लो पर मौजूदा प्रश्नों के लिंक है, इसलिए हमारे लिए उन्हें संदर्भित करना आसान है"।
— हर्बर्ट
3
एक सवाल आज (Nov.20 / 15) से पूछा गया कि stackoverflow.com/questions/33833259/what-is-rscat-in-php पूछने "क्या php में $ rsCat है" (यह सवाल अभी भी दिखाई दे बनाया जाना चाहिए और नहीं हटाए गए) । अजीब तरह से, $चर के बारे में एक संदर्भ नहीं है , लेकिन $$केवल चर चर के बारे में । मेरा मानना ​​है कि इसमें कहीं न कहीं संशोधन होना चाहिए।
— फिक फोर्टी निनेर

जवाबों:

1169

बढ़ाना / घटाना ऑपरेटरों

++ वेतन वृद्धि संचालक

-- कमी संचालक

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

ये चर से पहले या बाद में जा सकते हैं।

यदि चर के पहले रखा जाता है, तो वेतन वृद्धि / क्षरण संचालन पहले चर के लिए किया जाता है, फिर परिणाम लौटाया जाता है। यदि चर के बाद रखा जाता है, तो चर को पहले लौटाया जाता है, फिर वेतन वृद्धि / अपघटन संचालन किया जाता है।

उदाहरण के लिए:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

जीवंत उदाहरण

उपरोक्त मामले ++$iमें उपयोग किया जाता है, क्योंकि यह तेज है। $i++एक ही परिणाम होगा।

प्री-इन्क्रीमेंट थोड़ा तेज है क्योंकि यह वास्तव में वैरिएबल को बढ़ाता है और उसके बाद परिणाम देता है। पोस्ट-इन्क्रीमेंट एक विशेष वैरिएबल बनाता है, वहां पहले वैरिएबल का मान कॉपी करता है और पहला वैरिएबल इस्तेमाल होने के बाद ही दूसरे के वैल्यू को बदल देता है।

हालाँकि, आपको उपयोग करना होगा $apples--, पहले से, आप सेब की वर्तमान संख्या प्रदर्शित करना चाहते हैं, और फिर आप इसमें से एक को घटाना चाहते हैं।

आप PHP में पत्र भी बढ़ा सकते हैं:

$i = "a";
while ($i < "c") {
    echo $i++;
}

एक बार zपहुंच गया aaहै तो अगला है, इत्यादि।

ध्यान दें कि वर्ण चर को बढ़ाया जा सकता है, लेकिन घटाया नहीं जाता है और यहां तक ​​कि केवल सादे ASCII वर्ण (az और AZ) समर्थित हैं।

ढेर अतिप्रवाह पोस्ट:

— पीटर अज़ताई
स्रोत
9
नोट के लिए +1 कि डिक्रिप्टर्स वर्णों पर काम नहीं करते हैं, केवल संख्या पर
— मार्क बेकर
163
हर किसी की खातिर, कृपया पूर्व-इंक्रीमेंटिंग के बारे में बोल्ड जानकारी को हटा दें। यह समय से पहले अनुकूलन का सबसे खराब उदाहरण है और इस तरह की जानकारी लोगों के सिर में नहीं होनी चाहिए अगर वे सिर्फ पीएचपी सीखना शुरू कर रहे हैं।
— लोटस नोट्स
14
@ लोटस - मैं इसे एक मजेदार तथ्य मानता हूं। यदि आप PHP, या C ++, आदि के लिए एक शुरुआत कर रहे हैं, यह बहुत निराला लगता है कि ++ मैं और i ++ अलग गति पर काम करने के लिए पर्याप्त अलग हैं। मुझे यह आकर्षक लगा।
— पीटर अजताई
12
@Peter Ajtai हां, यह दिलचस्प है, लेकिन जिस तरह से आपने अपनी पोस्ट को संरचित किया है, उससे यह प्रतीत होता है कि यह PHP के प्रमुख तथ्यों में से एक है जो भाषा का उपयोग करने के लिए बिल्कुल महत्वपूर्ण है।
— लोटस नोट्स
4
निश्चित नहीं है कि यह सिर्फ मेरे लिए है या नहीं, लेकिन सेब का उदाहरण थोड़ा भ्रामक लगता है। 'मेरे पास 10 सेब हैं। मैंने सिर्फ एक खाया 'मुझे विश्वास है कि आपके पास 11 सेब थे, लेकिन अब आपके पास 10 हैं क्योंकि आपने 10 खाने के बाद एक खाने के बजाय सिर्फ एक खाया है, इस प्रकार आपको 9 बना दिया है - जो कि कोड लागू कर रहा है।
— さ げ な い
440

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

एक बिट क्या है? एक बिट 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, 2 और 1 कॉलम में 3 बिट सेट हैं। उन्हें जोड़ें: 8 + 2 + 1 = 11।

— अंकुर सक्सेना
स्रोत
6
क्या होगा यदि $ 255 से अधिक मूल्य लेता है?
— ऐकान येश्ट
@ AycanYaşıt अधिकांश ऑपरेटिंग सिस्टम 32 बिट और 64 बिट सिस्टम का उपयोग कर रहा है, इसका मतलब है कि सीमा 255 (8 बिट्स) से बहुत अधिक है।
— अल्बर्टसमुएल
@ AycanYaşıt वास्तव में, एक बाइट की लंबाई के साथ यहाँ प्रतिनिधित्व भी सही नहीं है, क्योंकि सबसे छोटा पूर्णांक अभी भी 64 बिट (8 बाइट) एक आधुनिक 64 बिट प्लेटफॉर्म पर स्मृति में है।
— काई
क्यों and &है 0 0 0 0 1 0 0 0 और or |है 0 0 0 0 1 0 1 1?
— वीर
285

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

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

अंतरिक्ष यान ऑपरेटर <=> नवीनतम तुलना ऑपरेटर पीएचपी 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;
});
— शेरिफ
स्रोत
21
यकीन नहीं है कि कैसे $a <=> $bअलग है$a - $b
— संशोधित करें
38
@AcidShout $a - $bसंख्याओं के लिए काम करता है, लेकिन तार, वस्तु या सरणियाँ नहीं।
— mcrumley
44
@mcrumley नहीं, यह उससे भी बदतर है। सामान्य तौर पर $a - $bसंख्याओं के लिए भी काम नहीं करता है; यह केवल पूर्णांकों के लिए काम करता है । यह गैर-पूर्णांक संख्याओं के लिए काम नहीं करता है, क्योंकि usortआपके तुलनित्र फ़ंक्शन के रिटर्न मानों को intकास्ट करता है, जिसका अर्थ है कि 0.5 0 से डाली जाती है, जिसका अर्थ है कि 1 से कम के अंतर वाले दो नंबर, जैसे 4 और 4.6, हो सकता है (निर्भर करता है) जिस पर कोई भी आपके तुलनित्र फ़ंक्शन के पहले तर्क के रूप में पास हो जाता है) गलत तरीके से बराबर की तुलना करता है।
— मार्क अमेरी
5
@ मकर्मी माइग्रेशन गाइड ऑपरेटर के प्रलेखित व्यवहार नहीं है। इसके लिए आप उस php.net/language.operators.com के लिए मैनुअल के भाषा ऑपरेटरों अनुभाग को देखना चाहते हैं। इसके पीछे वास्तविक व्यवहार एपीआई के विभिन्न तुलनात्मक कार्यों पर निर्भर करता है, जैसे कि आप स्ट्रिंग्स के लिए स्ट्रैम्प कर रहे हैं, जहां आप हर एक मामले में वास्तविक रिटर्न मूल्य की गारंटी नहीं दे सकते। निश्चित रूप से, यह लगभग हमेशा 1, 0 या -1 है, लेकिन उन मामलों के लिए जहां आप इसकी गारंटी नहीं दे सकते हैं जैसे लिबास के स्ट्रैम्प को लपेटने में, आप उसी परिभाषित व्यवहार को प्रस्तुत करते हैं जैसे कि सुरक्षित होने के लिए अंतर्निहित कल्पना
— शेरिफ
9
@MarkAmery यहां बिंदु लोगों को अपरिभाषित व्यवहार पर भरोसा करने की अनुमति नहीं है। एक मामले के लिए जहां किसी को एक मान मिलता है जो कि बिल्कुल 1, 0, या -1 नहीं है, तो आपको किसी को बग रिपोर्ट दाखिल करते हुए लगता है कि भाषा में कुछ गलत है। यही कारण है कि हम दस्तावेज़ है कि हम गारंटी दे सकते हैं कि मूल्य से कम , अधिक से अधिक , या 0 के बराबर , और जरूरी नहीं कि 1, 0, और -1 होगा।
— शेरिफ
273 
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
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"
— अंकुर सक्सेना
स्रोत
239

मैजिक कॉन्स्टेंट : हालांकि ये सिर्फ प्रतीक नहीं हैं, बल्कि इस टोकन परिवार का महत्वपूर्ण हिस्सा हैं। आठ जादुई स्थिरांक हैं जो कि उनके उपयोग के आधार पर बदलते हैं।

__LINE__: फ़ाइल की वर्तमान पंक्ति संख्या।

__FILE__: फ़ाइल का पूर्ण पथ और फ़ाइल नाम। यदि किसी शामिल के अंदर उपयोग किया जाता है, तो सम्मिलित फ़ाइल का नाम वापस आ जाता है। PHP 4.0.2 के बाद से, __FILE__सदैव हल किए गए सिमिलिंक के साथ एक पूर्ण पथ होता है जबकि पुराने संस्करणों में इसमें कुछ परिस्थितियों में सापेक्ष पथ समाहित होता है।

__DIR__: फ़ाइल की निर्देशिका। यदि किसी शामिल के अंदर उपयोग किया जाता है, तो शामिल फ़ाइल की निर्देशिका वापस कर दी जाती है। इसके बराबर है dirname(__FILE__)। जब तक यह रूट डायरेक्टरी न हो, तब तक इस निर्देशिका नाम में अनुगामी स्लेश नहीं होता है। (PHP 5.3.0 में जोड़ा गया।)

__FUNCTION__: समारोह का नाम। (PHP 4.3.0 में जोड़ा गया) PHP 5 के रूप में यह लगातार फंक्शन का नाम देता है क्योंकि इसे घोषित किया गया था (केस-संवेदी)। PHP 4 में इसका मान हमेशा कम होता है।

__CLASS__: वर्ग का नाम। (PHP 4.3.0 में जोड़ा गया) PHP 5 के रूप में यह निरंतर वर्ग का नाम देता है क्योंकि इसे घोषित किया गया था (केस-संवेदी)। PHP 4 में इसका मान हमेशा कम होता है। वर्ग के नाम में वे नामस्थान शामिल हैं, जिन्हें (जैसे Foo\Bar) घोषित किया गया था । ध्यान दें कि PHP 5.4 के रूप में __CLASS__भी लक्षण में काम करता है। जब एक विशेषता विधि में उपयोग किया जाता है, __CLASS__तो उस वर्ग का नाम होता है जिसमें विशेषता का उपयोग किया जाता है।

__TRAIT__: लक्षण नाम। (PHP 5.4.0 में जोड़ा गया) PHP 5.4 के रूप में यह स्थिरांक लौटाता है क्योंकि यह घोषित किया गया था (केस-संवेदी)। विशेषता नाम में वे नामस्थान शामिल हैं, जिन्हें (जैसे Foo\Bar) घोषित किया गया था ।

__METHOD__: कक्षा विधि नाम। (PHP 5.0.0 में जोड़ा गया) विधि नाम वापस कर दिया गया है क्योंकि यह घोषित किया गया था (केस-संवेदी)।

__NAMESPACE__: वर्तमान नामस्थान (केस-संवेदी) का नाम। यह स्थिरांक संकलन-समय (PHP 5.3.0 में जोड़ा गया) में परिभाषित किया गया है।

स्रोत

— n.1
स्रोत
150

संचालक टाइप करें

instanceof यह निर्धारित करने के लिए उपयोग किया जाता है कि PHP चर एक निश्चित वर्ग का तात्कालिक वस्तु है या नहीं।

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

उपरोक्त उदाहरण आउटपुट होगा:

bool(true)
bool(false)

कारण: उपर्युक्त उदाहरण $aएक ऐसी वस्तु है, जिसके साथ mclassकेवल mclassडेटा का उपयोग नहीं किया जाता हैsclass

विरासत के साथ उदाहरण

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

उपरोक्त उदाहरण आउटपुट होगा:

bool(true)
bool(true)

क्लोन के साथ उदाहरण

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

उपरोक्त उदाहरण आउटपुट होगा:

bool(true)
bool(true)
— मौलिक पटेल
स्रोत
7
उपरोक्त 'इंटरफेस' के साथ भी काम करता है। यह जाँचने के लिए उपयोगी है कि एक विशेष इंटरफ़ेस उपलब्ध है।
— रयान विंसेंट
132

PHP में ऑपरेटरों का अवलोकन :

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

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

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

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

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

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

बढ़ाई / घटती संचालकों:

  • ++ $ a : वृद्धि $ एक एक करके, फिर $ a लौटता है।
  • $ a ++ : Returns $ a, फिर एक-एक करके $ increments।
  • - $ a : एक के बाद $ $ घटता है, फिर $ a लौटता है।
  • $ a-- : रिटर्न $ a, तो एक-एक करके $ घटता है।

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

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

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

  • $ ए। $ b : $ a और $ b का समाकलन।

ऐरे ऑपरेटर:

  • $ a + $ b : $ a और $ b का मिलन।
  • $ a == $ b : TRUE यदि $ a और $ b में समान कुंजी / मान जोड़े हैं।
  • $ a === $ b : TRUE यदि $ a और $ b में समान क्रम और समान प्रकारों में समान कुंजी / मान जोड़े हैं।
  • $ a! = $ b : TRUE यदि $ a $ b के बराबर नहीं है।
  • $ a <> $ b : TRUE यदि $ a $ b के बराबर नहीं है।
  • $ a! == $ b : TRUE यदि $ a $ b के समान नहीं है।

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

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

ध्यान दें

andऑपरेटर और orऑपरेटर में असाइनमेंट ऑपरेटर की तुलना में कम पूर्वता होती है =।

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

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

— जॉन सेलर्स
स्रोत
1
इसमें कोई त्रुटि है $a ?? $c, यह कहते हैं कि यह समान है $a ? $a : $c, लेकिन टर्नरी ऑपरेटर जाँच करता है कि क्या मूल्य सत्य है, दूसरी ओर, शून्य मानों के लिए अशक्त coalescing जाँच करता है, इसलिए, यदि $ a 0 है, तो आपको 0 मिलेगा (क्योंकि 0 है) अशक्त नहीं), उदाहरण के लिए यदि आपके पास है: $a=0; $c=5;तो $a?$a:$c5 लौटाता है, और $a??$c
— 0.41
104

स्पेसशिप ऑपरेटर<=> (PHP 7 में जोड़ा गया)

<=>स्पेसशिप ऑपरेटर (PHP 7, स्रोत: PHP मैनुअल) के उदाहरण :

इंटेगर, फ्लोट्स, स्ट्रिंग्स, एरेज़ एंड ऑब्जेक्ट्स फॉर थ्री-वे वेरी ऑफ़ वेरिएबल्स।

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
// Comparison is case-sensitive
echo "B" <=> "a"; // -1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1
— राजगुप्त
स्रोत
1
संदर्भ के लिए php.net/manual/en/language.operators.comparison.php देखें
— rajangupta
74

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

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

$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
— रेव्ह mnv
स्रोत
4
{''} संपत्ति के नाम के लिए अंकन। गूंज $ फिल्में-> फिल्म -> {'महान-लाइनें'} -> लाइन; SimpleXMLElement में डेटा तक पहुंचने के लिए इस्तेमाल किया जा सकता है। शायद यह अन्य मामलों में भी इस्तेमाल किया जा सकता है। php.net/manual/en/simplexml.examples-basic.php
— आंद्रेई
68

अशक्त सहवर्ती ऑपरेटर (??)

PHP ऑपरेटर के साथ संयोजन के रूप में एक टर्नरी ऑपरेटर का उपयोग करने की आवश्यकता के सामान्य मामले के लिए इस ऑपरेटर को PHP 7.0 में जोड़ा गया है isset()। यदि यह मौजूद है और नहीं है तो यह अपना पहला ऑपरेंड लौटाता है 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';
?>
— VIPIN A ROY
स्रोत
64

PHP स्ट्रिंग्स: PHP स्ट्रिंग्स को केवल दो तरीकों से चार तरीकों से निर्दिष्ट किया जा सकता है:

1) एकल उद्धरण स्ट्रिंग्स: 

$string = 'This is my string'; // print This is my string

2) डबल भाव स्ट्रिंग्स: 

$str = 'string';

$string = "This is my $str"; // print This is my string

3) हेरेडोक: 

$string = <<<EOD
This is my string
EOD; // print This is my string

4) नॉवडोक (PHP 5.3.0 के बाद से): 

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string
— डेप्रो
स्रोत
@ Rizier123: "Heredocs का उपयोग क्लास की संपत्तियों को शुरू करने के लिए नहीं किया जा सकता है। PHP 5.3 के बाद से, यह सीमा केवल वेरिएबल वाले हेरेडोक्स के लिए मान्य है।"
— PHPFAN
48

सवाल:

क्या =>मतलब है?

उत्तर:

=>क्या प्रतीक है जिसे हम मनुष्यों ने "Key" => "Value"एसोसिएटिव एरे में अलग-अलग जोड़े के लिए उपयोग करने का निर्णय लिया है ।

विस्तार से चर्चा करते:

इसे समझने के लिए, हमें यह जानना होगा कि एसोसिएटिव एरर्स क्या हैं। जब एक पारंपरिक प्रोग्रामर एक सरणी ( PHP में ) के बारे में सोचता है तो पहली बात यह होती है:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

जहां, यदि हम कोड के कुछ बाद के हिस्से में सरणी को कॉल करना चाहते हैं, तो हम कर सकते हैं:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

अब तक सब ठीक है। हालांकि, मनुष्य के रूप में, हमें यह याद रखना मुश्किल है कि [0]सरणी का सूचकांक वर्ष 2016 का मूल्य है , [1]सरणी का सूचकांक एक अभिवादन है , और [2]सरणी का सूचकांक एक साधारण पूर्णांक मान है । इसके बाद हमें वैकल्पिक विकल्प का उपयोग करना होगा, जिसे एक सहयोगी सरणी कहा जाता है । एक साहचर्य सरणी में एक अनुक्रमिक सरणी से कुछ अंतर हैं ( जो कि पिछले मामलों में थे क्योंकि वे प्रत्येक पूर्व निर्धारित मूल्य के लिए 1 से वृद्धि करके पूर्वनिर्धारित अनुक्रम में उपयोग किए गए सूचकांक को बढ़ाते हैं। )।

अंतर ( एक अनुक्रमिक और साहचर्य सरणी के बीच ):

  • साहचर्य सरणी की घोषणा के बाद, आप न केवल उस valueचीज़ को शामिल करते हैं जिसे आप सरणी में रखना चाहते हैं, बल्कि आपने अनुक्रमणिका मान (जिसे कहा जाता है key) भी रखा है जिसका उपयोग आप सरणी को बाद के भागों में कॉल करते समय करना चाहते हैं। कोड। निम्नलिखित सिंटैक्स का उपयोग घोषणा के दौरान किया जाता है "key" => "value":।

  • एसोसिएटिव एरे का उपयोग करते समय, keyमान को वांछित प्राप्त करने के लिए फिर सरणी के सूचकांक के अंदर रखा जाएगा value।

उदाहरण के लिए:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

और अब, पहले जैसा ही आउटपुट प्राप्त करने के लिए, keyसरणियों के सूचकांक में मूल्य का उपयोग किया जाएगा:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

अंतिम बिंदु:

इसलिए उपरोक्त उदाहरण से, यह देखना बहुत आसान है कि =>प्रतीक का उपयोग किसी सरणी में प्रत्येक जोड़े keyऔर valueजोड़े के बीच एक सहयोगी सरणी के संबंध को व्यक्त करने के लिए किया जाता है , जो सरणी के भीतर मूल्यों की दीक्षा को दर्शाती है।

— वेबेंग को दर्शाता है
स्रोत
36

प्रश्न :

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

PHP "और" ऑपरेटर

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

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

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

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

तो उपरोक्त सभी बिटवाइज़ ऑपरेटर और बिट्स का खेल है।

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

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

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

<?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
— रेव। देवराज
स्रोत
30

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

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

उदाहरण

$a = 5

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

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

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

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

— पार्थ नायक
स्रोत
27

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

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

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

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

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

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

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

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

यह निर्माण उपयोगकर्ता इनपुट या मौजूदा कॉन्फ़िगरेशन से आने वाले एक या अधिक मानों को प्राथमिकता देने के लिए उपयोगी है, और यदि कॉन्फ़िगरेशन गायब है तो सुरक्षित रूप से दिए गए डिफ़ॉल्ट पर वापस गिरना। यह एक छोटी सी सुविधा की तरह है, लेकिन यह एक ऐसा है जो मुझे पता है कि मैं अपने अनुप्रयोगों को PHP 7 में अपग्रेड करते ही उपयोग करूंगा।

— योगी घोराचा
स्रोत
12

अशक्त वापसी प्रकार की घोषणा

PHP 7 रिटर्न प्रकार की घोषणाओं के लिए समर्थन जोड़ता है। इसी प्रकार तर्क की घोषणाओं के लिए, वापसी प्रकार की घोषणाएं उस प्रकार के मूल्य को निर्दिष्ट करती हैं जो किसी फ़ंक्शन से वापस किया जाएगा। तर्क प्रकार की घोषणाओं के लिए वही प्रकार उपलब्ध हैं जो तर्क प्रकार की घोषणाओं के लिए उपलब्ध हैं।

सख्त टाइपिंग का भी रिटर्न प्रकार की घोषणाओं पर प्रभाव पड़ता है। डिफ़ॉल्ट कमजोर मोड में, लौटाए गए मानों को सही प्रकार के लिए मजबूर किया जाएगा यदि वे पहले से ही उस प्रकार के नहीं हैं। मजबूत मोड में, लौटाया गया मान सही प्रकार का होना चाहिए, अन्यथा, टाइपर्रर को फेंक दिया जाएगा।

PHP 7.1.0 के रूप में, रिटर्न मानों को प्रश्न चिह्न (?) के साथ टाइप नाम को उपसर्ग करके अशक्त के रूप में चिह्नित किया जा सकता है। यह दर्शाता है कि फ़ंक्शन निर्दिष्ट प्रकार या NULL पर वापस लौटता है।

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

स्रोत

— जॉन कोनडे
स्रोत
7

तीन डॉट्स स्प्लैट ऑपरेटर (...) के रूप में (PHP 5.6 के बाद से)

PHP में एक ऑपरेटर "..." (थ्री डॉट्स) होता है जिसे स्पैट ऑपरेटर कहा जाता है। इसका उपयोग किसी फ़ंक्शन में मापदंडों की मनमानी संख्या को पारित करने के लिए किया जाता है और इस प्रकार के फ़ंक्शन को वैरिएड फ़ंक्शंस कहा जाता है। चलो "..." (तीन बिंदु) का उपयोग करने के लिए उदाहरण लेते हैं।

उदाहरण 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

परिकलन-भार () फ़ंक्शन के प्रत्येक तर्क "..." का उपयोग करते समय एक सरणी के रूप में $ परम से गुजरते हैं।

"..." ऑपरेटर का उपयोग करने के कई अलग-अलग तरीके हैं। कुछ उदाहरण नीचे:

उदाहरण 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

उदाहरण 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

उदाहरण 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>
— योगी घोराचा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.