A Range విలువల యొక్క విరామాన్ని సూచిస్తుంది — సంఖ్యల కోసం (1..10), అక్షరాల కోసం ('a'..'z'), మొదలైనవి. Ranges అనేవి ఉపయోగకరమైన పద్ధతులతో కూడిన objects, iteration, slicing, membership tests, మరియు case matching కోసం ఉపయోగించబడతాయి. అవి Ruby యొక్క ఒక సంక్షిప్త, వ్యక్తీకరణ లక్షణం.
(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
ముఖ్యమైన తేడా: .. చివరను చేర్చుకుంటుంది, ... దానిని除외 చేస్తుంది (మూడవ చుక్క "చివరను దూరంగా నెట్టివేస్తుంది"). గుర్తుంచుకోవలసిన సాధారణ విషయం.
(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 ను చేర్చుకుంటాయి, కాబట్టి అవి each, map, select, మొదలైనవిని సపోర్ట్ చేస్తాయి — మరియు to_a వాటిని array లోకి భౌతికీకరిస్తుంది.
(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 ను సమర్థవంతంగా పరీక్షిస్తాయి (ముఖ్యంగా cover?, ఇది పునరావృత్తి చేయకుండా endpoints ను మాత్రమే తనిఖీ చేస్తుంది).
# 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 అనేవి చాలా సాధారణ దృశ్యాలలో ఉపయోగించే ఉపయోగకరమైన, వ్యక్తీకరణ Ruby లక్షణం, కాబట్టి వాటిని అర్థం చేసుకోవడం విలువైన రోజువారీ జ్ఞానం.
వాటి విరామాలను సంక్షిప్తంగా సూచిస్తాయి (సంఖ్యా, వర్ణమాల) మరియు అనేక తరచుతర సందర్భాలలో కనిపిస్తాయి: iteration ((1..5).each — క్రమానికి పూచిపోయడానికి స్వచ్ఛమైన మార్గం), slicing arrays మరియు strings (arr[1..3], str[0..4] — sub-sequences ను చక్కగా సంగ్రహించుకోవడం), membership testing (include?/cover? — విలువ విరామంలో పడిందో లేదో తనిఖీ చేయడం, cover? endpoints ను మాత్రమే తనిఖీ చేయడం ద్వారా సమర్థవంతమైనది), మరియు ముఖ్యంగా case/when matching (స్వచ్ఛమైన range-ఆధారిత శాఖ, స్కోర్ ranges ద్వారా గ్రేడింగ్ వంటిది — సాధారణ, చదవదగిన నమూనా).
ముఖ్యమైన .. (చేర్చుకోవడం) vs ... (excluding) తేడాను అర్థం చేసుకోవడం ranges ని సరిగ్గా ఉపయోగించడానికి అవసరం (మరియు గందరగోళం యొక్క సాధారణ బిందువు).
Ranges Enumerable ను చేర్చుకుంటాయని (కాబట్టి అవి map/select/మొదలైనవిని సపోర్ట్ చేస్తాయని), iteration, slicing, membership కోసం వాటిని ఎలా ఉపయోగించాలో, మరియు ఆధునిక లక్షణాలు (endless/beginless ranges) ఆచరణాత్మక uses ను కవర్ చేస్తాయని తెలుసుకోవడం.
Ranges idiomatic Ruby లో తరచుగా కనిపిస్తుంటాయి (iteration, slicing, range-ఆధారిత నిబంధనలు, విలువ ranges యొక్క ధృవీకరణ), మరియు విరామాలను నిర్వహించటానికి అవి సంక్షిప్త, వ్యక్తీకరణ మార్గం కాబట్టి, ranges ను అర్థం చేసుకోవడం — వాటి syntax (inclusive vs exclusive), methods, మరియు సాధారణ uses (iteration, slicing, membership, case matching) — స్వచ్ఛమైన, idiomatic Ruby ను రాయడానికి ఉపయోగకరమైన, ఆచరణాత్మకంగా సంబంధితమైన జ్ఞానం క్రమాలను మరియు విరామాలను చక్కగా నిర్వహిస్తుంది.