रेंज जनरेशन में '..' (डबल-डॉट) और '...' (ट्रिपल-डॉट) के बीच अंतर?

Question

मैंने बस रूबी और रूबी को रेल पर सीखना शुरू कर दिया है और श्रेणियों का उपयोग करने वाले सत्यापन कोड में आया है:

validates_inclusion_of :age, :in => 21..99
validates_exclusion_of :age, :in => 0...21, :message => "Sorry, you must be over 21"

पहले मैंने सोचा था कि अंतर समापन बिंदुओं के समावेश में था, लेकिन एपीआई डॉक्स में मैंने देखा, इससे कोई फर्क नहीं पड़ता था कि यह था ..या ...: इसमें हमेशा समापन बिंदु शामिल थे।

हालांकि, मैंने irb में कुछ परीक्षण किया और यह संकेत देता है कि ..दोनों समापन बिंदु शामिल हैं, जबकि ...केवल निचले बाउंड को शामिल किया गया है लेकिन ऊपरी को शामिल नहीं किया गया है। क्या ये सही है?

Answer 1

रेंज के लिए दस्तावेज़ ^† इस कहते हैं:

रेंज का निर्माण ..शुरू से अंत तक समावेशी रूप से किया जाता है। ...अंत मूल्य को छोड़कर उन लोगों ने बनाया ।

तो a..bजैसा है a <= x <= b, जबकि a...bजैसा है a <= x < b।

---

ध्यान दें कि to_aपूर्णांक की एक सीमा पर, पूर्णांक का एक संग्रह देता है, एक श्रेणी मानों का एक सेट नहीं है, लेकिन बस शुरू / अंत मूल्यों की एक जोड़ी है:

(1..5).include?(5)           #=> true
(1...5).include?(5)          #=> false

(1..4).include?(4.1)         #=> false
(1...5).include?(4.1)        #=> true
(1..4).to_a == (1...5).to_a  #=> true
(1..4) == (1...5)            #=> false

^{D डॉक्स में इसे शामिल नहीं किया जाता था, इसके बजाय रेंजेस पर पिकैक्स के अनुभाग को पढ़ने की आवश्यकता होती है । इस अपडेट को देखने के लिए @MarkAmery ( नीचे देखें ) को धन्यवाद ।}

Comments

बेहतर / कम से कम ऊपर के उदाहरण भ्रमित: (1..10).include? 10 #=> trueऔर(1...10).include? 10 #=> false

— timmcliu

@timmcliu हालांकि इस बिंदु को दर्शाने के लिए प्रासंगिक नहीं है कि (a..b) != (a...(b+1))उनकी सरणी प्रतिनिधित्व बराबर होने के बावजूद (जब ए, बी u u)। मैंने उस पर विस्तार करने के लिए अपने उत्तर को थोड़ा अद्यतन किया है।

— एंड्रयू मार्शल

यदि रेंज मानों का एक सेट नहीं है, तो कोड का यह टुकड़ा मानों के एक सेट के रूप में रेंज का इलाज क्यों करता है: (1..5) .inject {sum, n | sum + n}

— VaVa

@ValentinVassilev रेंज मूल्यों का एक सेट नहीं है, लेकिन यह उन्हें उत्पन्न कर सकता है। injectसे आता है Enumerableजो Rangeभी शामिल है, Enumerableका उपयोग करता है #each, जो Rangeलागू करता है । द्वारा बनाई गई सूची Range#eachकभी भी Rangeवस्तु के भीतर निहित नहीं होती है।

— एंड्रयू मार्शल

Answer 2

वह सही है।

1.9.3p0 :005 > (1...10).to_a
 => [1, 2, 3, 4, 5, 6, 7, 8, 9]
1.9.3p0 :006 > (1..10).to_a
 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ट्रिपल-डॉट सिंटैक्स कम आम है, लेकिन की तुलना में अच्छा है (1..10-1).to_a

Comments

मुझे लगता है कि यह वास्तव में विचित्र है कि अधिक डॉट्स का मतलब है कि सीमा कम मूल्यों का प्रतिनिधित्व करती है। मुझे लगता है कि यह सिर्फ ..अधिक सामान्य है और इस प्रकार इसके लिए कम पसंद किया जाता है?

— एंड्रयू मार्शल

@ और: मैंने सोचा कि यह भी है, लेकिन शायद यह टू-डॉट किस्म के लिए अधिक सामान्यतः वांछित है और इस प्रकार टाइप करने के लिए कम है?

— सफारीटाइकोपी

यह भी ध्यान दें कि (a..b-1) != (a...b), हालांकि इस उत्तर का अर्थ है कि वे हैं।

— एंड्रयू मार्शल

(a..b-1) == (a ... b) केवल उस स्थिति में जहां a और b पूर्णांक होते हैं और आप श्रेणी को सरणियों में शामिल करते हैं। सीमा पर विचार करें (1.0 ... 3.5) - 3.5 के ठीक पहले क्या मूल्य है? निश्चित रूप से 2.5 नहीं!

— क्रिस हील्ड जूल

Answer 3

एपीआई डॉक्स अब इस व्यवहार का वर्णन करते हैं:

रेंज का निर्माण ..शुरू से अंत तक समावेशी रूप से किया जाता है। ...अंत मूल्य को छोड़कर उन लोगों ने बनाया ।

- http://ruby-doc.org/core-2.1.3/Range.html

दूसरे शब्दों में:

2.1.3 :001 > ('a'...'d').to_a
 => ["a", "b", "c"] 
2.1.3 :002 > ('a'..'d').to_a
 => ["a", "b", "c", "d"] 

Answer 4

a...b शामिल नहीं अंत मूल्य, जबकि a..b शामिल अंत मूल्य।

पूर्णांक के साथ काम करते समय, a...bजैसा व्यवहार करता है a..b-1।

>> (-1...3).to_a
=> [-1, 0, 1, 2]

>> (-1..2).to_a
=> [-1, 0, 1, 2]

>> (-1..2).to_a == (-1...3).to_a
=> true

लेकिन वास्तव में सीमाएं एक वास्तविक संख्या रेखा पर भिन्न होती हैं ।

>> (-1..2) == (-1...3)
=> false

इसे आप भिन्नात्मक चरणों में वृद्धि के दौरान देख सकते हैं।

>> (-1..2).step(0.5).to_a
=> [-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]

>> (-1...3).step(0.5).to_a
=> [-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5]

Comments

एडिट के बाद भी गलत है। भले ही aऔर bपूर्णांक हैं, रेंज अलग हैं। केवल जब प्रत्येक को किसी सरणी में बदला जाता है तो वे समान होते हैं। एक विशिष्ट प्रतिसाद स्वीकार किए गए उत्तर में मौजूद है।

— एंड्रयू मार्शल

@AndrewMarshall मेरा उस उदाहरण के साथ कहने का क्या मतलब था (लेकिन बहुत स्पष्ट रूप से नहीं) एक पूर्णांक पैमाने पर यह उस तरह से व्यवहार करता है। यह अधिक सटीक अंश पैमाने पर मामला नहीं है, जैसा कि आपके उत्तर में बताया गया है। मुझे लगता है कि सीमा रेखाओं का उपयोग अक्सर पूर्णांक पैमाने पर किया जाता है, यही वजह है कि मेरा मानना ​​है कि इस तरह की व्याख्या सहायक है।

— डेनिस

Answer 5

.. और ... एक श्रेणी निरूपित करें।

बस इसे irb में देखें:

ruby-1.9.2-p290 :032 > (1...2).each do puts "p" end
p
 => 1...2 
ruby-1.9.2-p290 :033 > (1..2).each do puts "p" end
p
p

Comments

वास्तव में सवाल का जवाब नहीं है, हालांकि; दोनों की सीमाएँ बताई गई हैं। समावेशी बनाम अनन्य रेंज।

— क्रेग रिंगर