रेल केस/स्विच पर रूबी। ऑब्जेक्ट के खिलाफ कैसे मिलान करें?

Question

मैं रेल आवेदन पर रूबी पर काम कर रहा हूं। एक सत्र नियंत्रक के लिए, मैं यह जांचने के लिए एक केस का उपयोग करना चाहता हूं कि उपयोगकर्ता का खाता लॉक है या प्रतिबंधित है या नहीं। मैं इस मामले के रूप में कक्षा के ऑब्जेक्ट का उपयोग करने की कोशिश कर रहा हूं, और विशेषताओं को जांचने के लिए उपयोग करता हूं।

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

user = Profile.find(1) 
case user 
when user.ban 
    redirect_to() 
when user.lock 
    redirect_to() 
else 
    redirect_to() 
end 

केवल समस्या यह है कि काम नहीं करता है।

क्या काम यह है करता है:

case user.ban 
when true 
    redirect_to() 
else 
    redirect_to() 
end 

कैसे मैं यदि कोई उपयोगकर्ता वस्तु पर प्रतिबंध लगा दिया या लॉक हो गया है एक स्विच का उपयोग की जाँच के बारे में जा सकते हैं पर कोई सलाह?

धन्यवाद

Answer 1

एक user.status विधि है जो एक उपयोगकर्ता के एक राज्य रिटर्न बनाओ, तो आप ऐसा कर सकते हैं:

user = Profile.find(1) 
case user.status 
when "banned" 
    redirect_to() 
when "locked" 
    redirect_to() 
else 
    redirect_to() 
end 

Answer 2

आप कर सकते हैं के रूप में Zepplock कहा। लेकिन दिए गए उदाहरण के लिए सबसे अच्छा तरीका है (केवल एक उदाहरण)

action_name = (user.ban)? "ban" : ((user.lock)? "lock" : "default") 
redirect_to(:action => action_name) 

Answer 3

मुझे @ सेलिल का जवाब पसंद है; लेकिन, अगर तुम सच में case चाहें, तो आप ऐसा कर सकते हैं:

case true 
    when user.ban 
    redirect_to() 
    when user.lock 
    redirect_to() 
    else 
    redirect_to() 
end 

अद्यतन जोर्ग कहा यह भी काम करता है, और वह सही है! उसे अपने जवाब पर कुछ वोट दें! (होगा जैसा कि मैंने)

case 
    when user.ban 
    redirect_to() 
    when user.lock 
    redirect_to() 
    else 
    redirect_to() 
end 

अद्यतन 2012 यह अब काम करता है:

case user 
    when lambda(&:ban) 
    redirect_to() 
    when lambda(&:lock) 
    redirect_to() 
    else 
    redirect_to() 
    end 
end 

Answer 4

@Brian, एक स्विच मामले का विचार है आप एक ऐसा वैरिएबल एक गतिशील मूल्य और यह जाँच करता है स्वीकार करता है मूल्यों के निरंतर सेट के दो जोड़े के खिलाफ। आपके द्वारा लिखे गए कोड के टुकड़े में, केस स्टेटमेंट में उपयोगकर्ता.बैन जैसे गतिशील मान होते हैं जो वेरिएबल पर निर्भर करता है जिसे आप जांचने का प्रयास कर रहे हैं। स्विच केस का उपयोग करने का सही तरीका यह है कि @Zepplock ने कैसे प्रदर्शित किया।

Answer 5

लॉल, मुझे अमादन का जवाब पसंद है। और यदि आप वास्तव में एक केस स्टेटमेंट चाहते हैं, तो आपको शायद ऐसा करना चाहिए जो ज़ेप्लॉक ने कहा था (हालांकि तारों के स्थान पर प्रतीकों पर विचार किया जा सकता है), लेकिन आपके उपयोग के मामले के आधार पर, आप सलिल की तरह अधिक कथन आधारित समाधान चाहते हैं।

वैसे भी, सोचा था कि मैं में कुछ मजा भी फेंक और होगा^_^ यहाँ एक समाधान है कि तुम क्या कहा, यह ऑब्जेक्ट === करने के लिए (क्या मामला बयानों का उपयोग करें) जवाब है, तो बनाता है के साथ काम करेंगे है वे ब्याज की विधि (ताला या प्रतिबंध) का आह्वान करते हैं और इसे वापस करते हैं। आप शायद उन्हें config या प्रारंभकर्ता किसी प्रकार में डाल दिया जाना चाहिए, या अन्यथा, पहले मंगलाचरण के बाद परिणाम की दुकान आदेश प्रदर्शन को बचाने के लिए

user = Class.new do 
    def ban() true end 
    def lock() true end 
end.new 

def banned? 
    ban_checker = Object.new 
    def ban_checker.===(user) user.ban end 
    ban_checker 
end 

def locked? 
    lock_checker = Object.new 
    def lock_checker.===(user) user.lock end 
    lock_checker 
end 

case user 
when banned? 
    puts 'banned' 
when locked? 
    puts 'locked' 
else 
    puts 'default' 
end 

नोट (आपका ऐप्लिकेशन केवल इन वस्तुओं एक बार बनाने के लिए की जरूरत है): मैं मैं इस समाधान की वकालत नहीं कर रहा हूं, क्योंकि यह encapsulation का उल्लंघन करता है। प्रतिबंधित आपके उपयोगकर्ता पर परिभाषित और उपयोग किया जाना चाहिए, लेकिन यह काम करने के लिए, इसे संलग्न क्षेत्र में परिभाषित किया जाना चाहिए।मैं ज्यादातर इस मस्ती के लिए ऊपर लाने :)

Answer 6

बस user बाहर छोड़:

user = Profile.find(1) 
case 
when user.ban 
    redirect_to 
when user.lock 
    redirect_to 
else 
    redirect_to 
end 

रूबी में, वहाँ case अभिव्यक्ति के दो प्रकार हैं। उपर्युक्त रूप में, यह केवल पहली शाखा निष्पादित करता है जो एक वास्तविक मूल्य का मूल्यांकन करता है (यानी nil या false को छोड़कर कुछ भी)।

अन्य रूप

case foo 
when bar 
    baz 
end 

को

if bar === foo 
    baz 
end