यह निर्धारित करना कि क्या कोई चर श्रेणी के भीतर है?

Question

मुझे एक लूप लिखने की ज़रूरत है जो कुछ ऐसा करता है:

if i (1..10)
  do thing 1
elsif i (11..20)
  do thing 2
elsif i (21..30)
  do thing 3
etc...

लेकिन अब तक वाक्य रचना के संदर्भ में गलत रास्ते पर चले गए हैं।

Answer 1

अगर i.between (1, 10)
  बात १ 
एल्सिफ आई.बेटन (11,20)
  बात २ 
...

Comments

यह भी वस्तुओं Dateऔर DateTimeवस्तुओं के लिए काम करता है जबकि ===ऐसा नहीं है।

— आदित्य

i.between?(1..10)काम नहीं करेगा (यदि यह है ..) तो मुझे लगता है कि इसके लिए एक कारण होना चाहिए

— nonopolarity

के बीच? दो मापदंडों की आवश्यकता होगी, यह सीमा की अनुमति नहीं देगा।

— मनीष नागदेवानी

क्या यह समावेशी या अनन्य है?

— andrewcockerham

@andrewcockerham समावेशी। 3.between?(1, 3) => true

— टायलर जेम्स यंग

Answer 2

===ऑपरेटर (या इसके पर्यायवाची include?) का उपयोग करें

if (1..10) === i

Comments

iएक नंबर (जैसे nil) से कुछ और होने के साथ काम करने का अच्छा लाभ भी है

— क्रिस्टोफर क्लैंग

यदि रेंज काफी बड़ी हो गई होती तो बहुत कुशल समाधान नहीं लगता।

— नवबंर

भविष्य के पाठक के लिए, वैकल्पिक तरीका if i === (1..10)काम नहीं करेगा

— अनवर

@ श्रद्धा, क्यों? (1..10000000000000000) एक सरणी नहीं है। (1..10000000000000000) === 5000000000000000बस हुड के नीचे एक "बीच" परीक्षण कर रहा है

— जॉन ला रूय

@ अनवर आपको समझा सकते हैं कि यह दूसरे तरीके से काम क्यों नहीं करता है?

— गोविंद राय

Answer 3

जैसा कि @ बालदू ने कहा, === ऑपरेटर का उपयोग करें या केस का उपयोग करें / जब जो आंतरिक रूप से === का उपयोग करता है:

case i
when 1..10
  # do thing 1
when 11..20
  # do thing 2
when 21..30
  # do thing 3
etc...

Comments

सभी जवाबों की, यह भी संभावना है कि जब आपके पास कई रेंज हों।

— xentek

Answer 4

यदि आप अभी भी श्रेणियों का उपयोग करना चाहते हैं ...

def foo(x)
 if (1..10).include?(x)
   puts "1 to 10"
 elsif (11..20).include?(x)
   puts "11 to 20"
 end
end

Answer 5

आप आमतौर पर कुछ के साथ बहुत बेहतर प्रदर्शन प्राप्त कर सकते हैं:

if i >= 21
  # do thing 3
elsif i >= 11
  # do thing 2
elsif i >= 1
  # do thing 1

Answer 6

आप उपयोग कर सकते हैं
if (1..10).cover? i then thing_1 elsif (11..20).cover? i then thing_2

और फास्ट रूबी में इस बेंचमार्क के अनुसार की तुलना में तेज हैinclude?

Comments

यह वास्तव में बहुत तेज है

— जो हाफ फेस

Answer 7

प्रश्न का सीधा उत्तर नहीं है, लेकिन यदि आप "भीतर" के विपरीत चाहते हैं:

(2..5).exclude?(7)

सच

Comments

ध्यान दें कि exclude?एक रेल जोड़ है ।

— जन क्लिमो

Answer 8

एक अधिक गतिशील उत्तर, जिसे रूबी में बनाया जा सकता है:

def select_f_from(collection, point) 
  collection.each do |cutoff, f|
    if point <= cutoff
      return f
    end
  end
  return nil
end

def foo(x)
  collection = [ [ 0, nil ],
                 [ 10, lambda { puts "doing thing 1"} ],
                 [ 20, lambda { puts "doing thing 2"} ],
                 [ 30, lambda { puts "doing thing 3"} ],
                 [ 40, nil ] ]

  f = select_f_from(collection, x)
  f.call if f
end

तो, इस मामले में, सीमाएं पकड़ने के लिए "पर्वतमाला" को वास्तव में केवल नील के साथ चित्रित किया जाता है।

Answer 9

स्ट्रिंग्स के लिए:

(["GRACE", "WEEKLY", "DAILY5"]).include?("GRACE")

# => True