PHP में Short-ternary और Null Coalescing ऑपरेटर: पूरी तुलना

एल्विस कौन है और PHP से इसका क्या संबंध?

अगर आपने कभी PHP में कोड लिखा है, तो आपने दूसरों के कोड में अजीब-सी चीज़ें ज़रूर देखी होंगी: $name ?: 'अतिथि' या $name ?? 'अतिथि'। पहली नज़र में ये एक जैसी लगती हैं। लेकिन असल में, इन दोनों ऑपरेटरों के पीछे बिल्कुल अलग-अलग मैकेनिज़्म छिपे हैं, जो आपके कोड को बचा भी सकते हैं और मुश्किल में भी डाल सकते हैं।

Stack Overflow पर सवाल "PHP short-ternary ("Elvis") operator vs null coalescing operator" को हज़ारों बार देखा जा चुका है। और यह कोई संयोग नहीं है। डेवलपर्स अक्सर इनमें भ्रमित हो जाते हैं, गलतियाँ करते हैं, और फिर बग्स ढूंढने में घंटों लगा देते हैं। आइए, एक बार और हमेशा के लिए समझ लें कि कौन क्या है, और अनुमान लगाना बंद करें।

इस लेख में हम सिर्फ अंतर नहीं बताएंगे। हम PHP के अंदरूनी कामकाज में झांकेंगे, प्रोडक्शन के रियल केस देखेंगे, और समझेंगे कि कब किस ऑपरेटर का उपयोग करना चाहिए। चलिए शुरू करते हैं!

त्वरित परिचय: ये क्या चीज़ें हैं?

टर्नरी ऑपरेटर (क्लासिक)

पहले बेसिक समझ लेते हैं। टर्नरी ऑपरेटर if-else का छोटा रूप है:

$age = 20;\n$status = ($age >= 18) ? 'वयस्क' : 'बच्चा';\n// $status = 'वयस्क'

बहुत सरल: अगर शर्त सही (true) है तो पहला मान लें, नहीं तो दूसरा।

Short-ternary (उर्फ Elvis operator) — ?:

यह उस स्थिति के लिए शॉर्टकट है जब आप किसी वेरिएबल को "सत्यता" (truthy) के लिए जांच रहे हैं और उसी वेरिएबल का मान उपयोग करना चाहते हैं:

$name = 'राहुल';\n$greeting = $name ?: 'अतिथि';\n// $greeting = 'राहुल'\n\n$name = '';\n$greeting = $name ?: 'अतिथि';\n// $greeting = 'अतिथि'

यह ऐसे काम करता है: अगर $name को true में बदला जा सकता है, तो $name लें। नहीं तो "अतिथि"।

Null coalescing operator — ??

यह PHP 7.0 में आया और तुरंत डेवलपर्स का पसंदीदा बन गया:

$name = 'राहुल';\n$greeting = $name ?? 'अतिथि';\n// $greeting = 'राहुल'\n\n$name = null;\n$greeting = $name ?? 'अतिथि';\n// $greeting = 'अतिथि'

एल्विस से अंतर: यह जांच सिर्फ null पर करता है, न कि पूरी "झूठ" (falsy) पर।

मुख्य अंतर: किसे "खाली" माना जाता है?

यहाँ से असली मज़ा शुरू होता है। आइए, विभिन्न $value मानों के लिए तुलना तालिका देखें:

$value = false;\necho $value ?: 'default'; // 'default' (false — यह "झूठ" है)\necho $value ?? 'default'; // false (false — यह null नहीं है)\n\n$value = 0;\necho $value ?: 'default'; // 'default' (0 — यह "झूठ" है)\necho $value ?? 'default'; // 0 (0 — यह null नहीं है)\n\n$value = '';\necho $value ?: 'default'; // 'default' (खाली स्ट्रिंग — यह "झूठ" है)\necho $value ?? 'default'; // '' (खाली स्ट्रिंग — यह null नहीं है)\n\n$value = [];\necho $value ?: 'default'; // 'default' (खाली ऐरे — यह "झूठ" है)\necho $value ?? 'default'; // [] (खाली ऐरे — यह null नहीं है)\n\n$value = '0';\necho $value ?: 'default'; // 'default' (स्ट्रिंग "0" — यह "झूठ" है!)\necho $value ?? 'default'; // '0' (स्ट्रिंग "0" — यह null नहीं है)

अंतर देखा? एल्विस "सत्यता" (truthy/falsy) की जांच करता है, जबकि null coalescing सिर्फ अस्तित्व और null से अलग होने की सख्त जांच करता है।

अंदरूनी कामकाज: इंजन स्तर पर यह कैसे काम करता है

आइए PHP के सोर्स कोड में झांकें (लगभग)। अगर आपने कभी PHP को सोर्स से कंपाइल किया है, तो आप जानते हैं कि दोनों ऑपरेटर पार्सिंग स्टेज पर प्रोसेस होते हैं।

Short-ternary (?):

असल में, यह सिंटैक्स शुगर है। $a ?: $b को $a ? $a : $b में बदल दिया जाता है। लेकिन एक बारीकी है: PHP $a को दो बार कैलकुलेट नहीं करता। यह रिजल्ट को एक टेम्परेरी वेरिएबल में सेव कर लेता है। यह साइड इफेक्ट वाले फंक्शन्स के लिए महत्वपूर्ण है:

function getData() {\n    echo "फंक्शन कॉल हुआ!\\n";\n    return rand(0, 1) ? 'data' : '';\n}\n\n// एल्विस फंक्शन को सिर्फ एक बार कॉल करेगा\n$result = getData() ?: 'default';\n// "फंक्शन कॉल हुआ!" — सिर्फ एक बार

अगर PHP $a को दो बार कैलकुलेट करता, तो फंक्शन दो बार कॉल होता और हर बार अलग रिजल्ट आ सकता था।