Ruby में टर्नरी ऑपरेटर क्या है?
एक टर्नरी ऑपरेटर तीन भागों से बना होता है, इसी से "टर्नरी" शब्द आया है। इन भागों में एक कंडीशनल स्टेटमेंट और दो संभावित परिणाम शामिल हैं।
दूसरे शब्दों में, एक टर्नरी आपको केवल एक लाइन कोड में एक कॉम्पैक्ट if/else एक्सप्रेशन लिखने का एक तरीका देता है।
उदाहरण के लिए:
if apple_stock > 1 :eat_apple else :buy_apple end
यह बन सकता है:
apple_stock > 1 ? :eat_apple : :buy_apple
टर्नरी ऑपरेटर का धन्यवाद!
प्रश्न...
यह वास्तव में कैसे काम करता है और उचित सिंटैक्स क्या है?
आइए पता लगाते हैं।
अपना खुद का टर्नरी लिखने के लिए एक टेम्पलेट
यदि हम टर्नरी ऑपरेटर के सिंटैक्स को सामान्यीकृत करते हैं तो आपको एक "फिल इन द ब्लैंक्स" प्रकार का टेम्पलेट मिलता है।
यह इस तरह दिखता है:
condition ? true : false
टर्नरी ऑपरेटर का पहला भाग कंडीशन है, जैसा कि वह कंडीशन जिसे आप चेक करना चाहते हैं कि वह true है या नहीं।
उसके बाद, हमारे पास एक क्वेश्चन मार्क (?) है।
यह सिंटैक्स का हिस्सा है!
यह है कि Ruby कैसे जानता है कि आप एक टर्नरी ऑपरेटर लिख रहे हैं।
अगला:
हमारे पास वह कोड है जिसे आप चलाना चाहते हैं यदि कंडीशन true निकलती है, पहला संभावित परिणाम।
फिर एक कोलन (:), एक और सिंटैक्स एलिमेंट।
अंत में, हमारे पास वह कोड है जिसे आप चलाना चाहते हैं यदि कंडीशन false है, दूसरा संभावित परिणाम।
उदाहरण:
"chocolate".size > 4 ? "चार कैरेक्टर्स से अधिक" : "चार कैरेक्टर्स से कम"
- Condition =>
"chocolate".size > 4 - If True =>
"चार कैरेक्टर्स से अधिक" - Else =>
"चार कैरेक्टर्स से कम"
ये तीन भाग हर टर्नरी एक्सप्रेशन के घटक हैं।
अपने ? को कंडीशन और संभावित परिणामों के बीच न भूलें, भले ही मेथड का नाम क्वेश्चन मार्क में समाप्त होता हो।
उदाहरण:
"".empty? ? "हाँ" : "नहीं"
इसे अनदेखा करना आसान है, इसलिए इस तरह का कोड लिखते समय ध्यान दें।
कॉम्प्लेक्स टर्नरी ऑपरेटर्स
टर्नरी ऑपरेटर का गलत उपयोग किया जा सकता है।
जब भी आप इसके साथ कुछ कॉम्प्लेक्स करना चाहते हैं तो यह एक बुरा विचार बनने लगता है।
उदाहरण के लिए:
आप एक टर्नरी एक्सप्रेशन के परिणाम को एक वेरिएबल में असाइन कर सकते हैं।
a = 10 > 5 ? "yes" : "no"
यह ठीक है।
लेकिन जब आपके संभावित परिणामों में स्पेस होते हैं तो यह अधिक जटिल होने लगता है।
यहाँ एक उदाहरण है:
10 > 5 ? (puts "yes") : (puts "no")
हमें यहाँ पैरेन्थिसिस का उपयोग करना होगा।
क्यों?
क्योंकि यदि आप नहीं करते हैं, तो आपको एक SyntaxError मिलता है।
ये पैरेन्थिसिस इस कोड को थोड़ा समझने में कठिन बनाते हैं, जो रीडेबिलिटी और टर्नरी का उपयोग करने के स्टाइल लाभों को कम करता है।
टर्नरी का उपयोग करना है या नहीं, यह चुनते समय इसे ध्यान में रखें।
टर्नरी ऑपरेटर्स और ऑपरेटर प्रीसेडेंस
टर्नरी एक्सप्रेशन के साथ आने वाला एक और मुद्दा ऑपरेटर प्रीसेडेंस है।
यहाँ एक उदाहरण है:
[].tap { |a| a << "ccccc".size == 0 ? "empty" : "not empty" } # [5]
मैं या तो "empty" या "not empty" की उम्मीद करूंगा, हमारे टर्नरी के लिए दो संभावित परिणाम, लेकिन हमें बजाय 5 मिला।
क्या हो रहा है?
यह पता चला है कि Ruby और अधिकांश प्रोग्रामिंग लैंग्वेजेस अलग-अलग प्राथमिकता स्तरों के साथ एक्सप्रेशन को प्रोसेस करते हैं।
यह सरल अंकगणित में भी होता है!
जैसा कि आप जानते हैं, गुणा का मूल्यांकन जोड़ और घटाव से पहले किया जाता है।
इसी तरह, Ruby में, एक मेथड कॉल (<< और size) टर्नरी ऑपरेटर पर प्रीसेडेंस लेता है, जो अंतिम उदाहरण में व्यवहार की व्याख्या करता है।
आप इसे पैरेन्थिसिस से हल कर सकते हैं:
[].tap { |a| a << ("bbbbb".size == 0 ? "empty" : "not empty") } # ["not empty"]
अपने टर्नरी ऑपरेटर्स लिखते समय ध्यान में रखने वाली एक और बात!
वीडियो ट्यूटोरियल
सारांश
आपने Ruby में टर्नरी कंडीशनल ऑपरेटर के बारे में सीखा, यह ऑपरेटर आपको कॉम्पैक्ट कंडीशनल स्टेटमेंट्स लिखने की अनुमति देता है जो स्थिति के आधार पर आपके कोड को पढ़ने में आसान या कठिन बना सकते हैं।
अब आपकी बारी है! जो आपने सीखा उसका अभ्यास करें ताकि आप इस ज्ञान को अपने दिमाग में इंस्टॉल कर सकें।
पढ़ने के लिए धन्यवाद 🙂
