एक Range values के एक interval का प्रतिनिधित्व करता है — numbers के लिए (1..10), letters के लिए ('a'..'z'), आदि। Ranges उपयोगी methods वाले objects हैं, जो iteration, slicing, membership tests, और case matching के लिए उपयोग किए जाते हैं। ये एक concise, expressive Ruby feature हैं।
(1..5) # INCLUSIVE — 1, 2, 3, 4, 5 (includes the end)
(1...5) # EXCLUSIVE — 1, 2, 3, 4 (excludes the end)
('a'..'e') # 'a', 'b', 'c', 'd', 'e' — works on letters too
Key अंतर: .. end को include करता है, ... इसे exclude करता है (तीसरा dot "end को दूर धकेलता है")। याद रखने योग्य एक common बिंदु।
(1..5).each { |n| puts n } # iterate — 1 to 5
(1..5).to_a # [1, 2, 3, 4, 5] — convert to an array
(1..10).map { |n| n * 2 } # ranges support Enumerable methods
(1..100).sum # 5050
(1..10).select(&:even?) # [2, 4, 6, 8, 10]
Ranges Enumerable को include करते हैं, इसलिए वे each, map, select, आदि को support करते हैं — और to_a उन्हें एक array में materialize करता है।
(1..100).include?(50) # true
(1..100).cover?(50) # true — faster (doesn't iterate, just checks endpoints)
age = 25
(18..65).include?(age) # check if a value falls in a range
include?/cover? membership को efficiently test करते हैं (विशेष रूप से cover?, जो बिना iterate किए केवल endpoints check करता है)।
# case/when with ranges — clean range-based branching
grade = case score
when 90..100 then "A"
when 80..89 then "B"
when 0..79 then "F"
end
# array/string slicing with ranges
[10, 20, 30, 40, 50][1..3] # [20, 30, 40] — slice by range
"hello world"[0..4] # "hello" — substring by range
# endless/beginless ranges (Ruby 2.6+)
arr[2..] # from index 2 to the end
(1..) # 1 to infinity (with lazy evaluation)
Ranges एक उपयोगी, expressive Ruby feature हैं जो कई common scenarios में उपयोग किए जाते हैं, इसलिए उन्हें समझना मूल्यवान रोज़मर्रा का ज्ञान है।
वे संक्षेप में intervals (numeric, alphabetic) का प्रतिनिधित्व करते हैं और कई frequent contexts में दिखाई देते हैं: iteration ((1..5).each — एक sequence पर loop करने का एक clean तरीका), arrays और strings की slicing (arr[1..3], str[0..4] — sub-sequences को elegantly extract करना), membership testing (include?/cover? — यह जांचना कि क्या कोई value एक interval में आती है, cover? केवल endpoints check करके efficient है), और विशेष रूप से case/when matching (clean range-based branching, जैसे score ranges द्वारा grading — एक common, readable pattern)।
महत्वपूर्ण .. (inclusive) बनाम ... (exclusive) अंतर को समझना ranges को सही ढंग से उपयोग करने के लिए आवश्यक है (और confusion का एक common बिंदु)।
यह जानना कि ranges Enumerable को include करते हैं (इसलिए वे map/select/आदि को support करते हैं), iteration, slicing, membership, और case matching के लिए उनका उपयोग कैसे करें, और modern features (endless/beginless ranges) practical उपयोगों को कवर करता है।
चूँकि ranges idiomatic Ruby में बार-बार दिखाई देते हैं (iteration, slicing, range-based conditionals, value ranges का validation), और चूँकि वे intervals को handle करने का एक concise, expressive तरीका हैं, ranges को समझना — उनका syntax (inclusive बनाम exclusive), methods, और common उपयोग (iteration, slicing, membership, case matching) — sequences और intervals को elegantly handle करने वाला clean, idiomatic Ruby लिखने के लिए उपयोगी, practically relevant ज्ञान है।