? :
रूबी में सशर्त ऑपरेटर ( ) का उपयोग कैसे किया जाता है?
उदाहरण के लिए, क्या यह सही है?
<% question = question.size > 20 ? question.question.slice(0, 20)+"..." : question.question %>
? :
रूबी में सशर्त ऑपरेटर ( ) का उपयोग कैसे किया जाता है?
उदाहरण के लिए, क्या यह सही है?
<% question = question.size > 20 ? question.question.slice(0, 20)+"..." : question.question %>
जवाबों:
यह टर्नरी ऑपरेटर है , और यह सी की तरह काम करता है (कोष्ठक की आवश्यकता नहीं है)। यह एक अभिव्यक्ति है जो काम करती है:
if_this_is_a_true_value ? then_the_result_is_this : else_it_is_this
हालांकि, रूबी में, if
यह भी एक अभिव्यक्ति है: if a then b else c end
=== a ? b : c
, पूर्ववर्ती मुद्दों को छोड़कर। दोनों ही भाव हैं।
उदाहरण:
puts (if 1 then 2 else 3 end) # => 2
puts 1 ? 2 : 3 # => 2
x = if 1 then 2 else 3 end
puts x # => 2
ध्यान दें कि पहले मामले में कोष्ठक की आवश्यकता होती है (अन्यथा रूबी भ्रमित है क्योंकि यह सोचता है कि यह इसके puts if 1
बाद कुछ अतिरिक्त कबाड़ के साथ है), लेकिन उन्हें अंतिम मामले में आवश्यक नहीं है क्योंकि कहा जाता है कि मुद्दा नहीं उठता है।
आप कई लाइनों पर पठनीयता के लिए "लंबे-अगर" फॉर्म का उपयोग कर सकते हैं:
question = if question.size > 20 then
question.slice(0, 20) + "..."
else
question
end
nil
और false
। वास्तव में बहुत सामान्य नहीं है।
puts true ? "true" : "false"
=> "true"
puts false ? "true" : "false"
=> "false"
puts (true ? "true" : "false")
कोष्ठक के साथ संपादित करें । अन्यथा संचालन का क्रम स्पष्ट नहीं है। जब मैंने पहली बार इसे पढ़ा तो मैं उलझन में था क्योंकि मैंने इसे पढ़ा था और (puts true) ? "true" : "false"
फिर puts
बूलियन को वापस करने की उम्मीद की जो तब स्ट्रिंग मान बन गया।
ईआरबी के आपके उपयोग से पता चलता है कि आप रेल में हैं। यदि ऐसा है, तो विचार करें truncate
, एक अंतर्निहित सहायक जो आपके लिए काम करेगा:
<% question = truncate(question, :length=>30) %>
@ पीएसटी ने एक शानदार जवाब दिया, लेकिन मैं यह उल्लेख करना चाहता हूं कि रूबी में टर्नरी ऑपरेटर को एक पंक्ति पर लिखा जाता है, जो पर्ल और सी के विपरीत, जहां हम इसे कई पंक्तियों में लिख सकते हैं, के विपरीत सिंटैक्टली सही है।
(true) ? 1 : 0
यदि आप इसे कई लाइनों में विभाजित करने का प्रयास करते हैं, तो आम तौर पर रूबी एक त्रुटि उठाएगी, लेकिन आप इसका उपयोग कर सकते हैं \
एक पंक्ति के अंत में लाइन-निरंतरता प्रतीक का और रूबी खुश हो जाएगी:
(true) \
? 1 \
: 0
यह एक सरल उदाहरण है, लेकिन लंबी लाइनों से निपटने के दौरान यह बहुत उपयोगी हो सकता है क्योंकि यह कोड को अच्छी तरह से बाहर रखता है।
परिचालकों को लाइन में लाए बिना लाइन-कंटिन्यू कैरेक्टर्स के बिना टर्नेरी का उपयोग करना भी संभव है, लेकिन मुझे यह पसंद नहीं है और इसकी अनुशंसा नहीं करता है:
(true) ?
1 :
0
मुझे लगता है कि सशर्त परीक्षा के रूप में कोड को पढ़ने के लिए वास्तव में कठिन होता है और / या परिणाम लंबे समय तक मिलते हैं।
मैंने टिप्पणियों को यह कहते हुए पढ़ा है कि टर्नरी ऑपरेटर का उपयोग नहीं करना क्योंकि यह भ्रामक है, लेकिन यह कुछ उपयोग नहीं करने का एक बुरा कारण है। उसी तर्क के द्वारा हमें नियमित अभिव्यक्ति, रेंज ऑपरेटर (' ..
' और ' ' प्रतीत होता है "फ्लिप-फ्लॉप" भिन्नता) का उपयोग नहीं करना चाहिए । जब वे सही ढंग से उपयोग किए जाते हैं तो वे शक्तिशाली होते हैं, इसलिए हमें उन्हें सही तरीके से उपयोग करना सीखना चाहिए।
आपने चारों ओर कोष्ठक क्यों लगाए हैं
true
?
ओपी के उदाहरण पर विचार करें:
<% question = question.size > 20 ? question.question.slice(0, 20)+"..." : question.question %>
सशर्त परीक्षण लपेटने से इसे अधिक पठनीय बनाने में मदद मिलती है क्योंकि यह नेत्रहीन रूप से परीक्षण को अलग करता है:
<% question = (question.size > 20) ? question.question.slice(0, 20)+"..." : question.question %>
बेशक, पूरे उदाहरण को व्हॉट्सएप के कुछ विवेकपूर्ण परिवर्धन का उपयोग करके बहुत अधिक पठनीय बनाया जा सकता है। यह अप्राप्त है लेकिन आपको यह विचार मिलेगा:
<% question = (question.size > 20) ? question.question.slice(0, 20) + "..." \
: question.question
%>
या, अधिक मुहावरेदार लिखा:
<% question = if (question.size > 20)
question.question.slice(0, 20) + "..."
else
question.question
end
%>
यह तर्क देना आसान होगा कि पठनीयता question.question
भी बुरी तरह से ग्रस्त है।
true
?
true
वास्तव में इसके लिए बैठे हैं जो एक अभिव्यक्ति होगी जो true
या का मूल्यांकन करता है false
। बेहतर है कि वे नेत्रहीन परिसीमन करें क्योंकि टर्नरी स्टेटमेंट जल्दी से दृश्य शोर में विकसित हो सकते हैं, पठनीयता को कम करते हैं जो स्थिरता को प्रभावित करता है।
एक सरल उदाहरण जहां ऑपरेटर जाँचता है कि खिलाड़ी की आईडी 1 है और परिणाम के आधार पर दुश्मन आईडी सेट करता है
player_id=1
....
player_id==1? enemy_id=2 : enemy_id=1
# => enemy=2
और मुझे इस विषय के बारे में एक पोस्ट मिली जो बहुत मददगार लगती है।
enemy_id = player_id == 1 ? 2 : 1
?
कोड condition ? statement_A : statement_B
के बराबर है
if condition == true
statement_A
else
statement_B
end
सबसे आसान तरीका:
param_a = 1
param_b = 2
result = param_a === param_b ? 'Same!' : 'Not same!'
के बाद से param_a
के बराबर नहीं है param_b
तो result
के मूल्य हो जाएगाNot same!
question=question[0,20]
आप इसे पूरा कर सकते हैं: यदि यह 20 से छोटा था, तो यह इसे किसी भी तरह से नहीं बदलेगा।