રેન્જ મૂલ્યોનો અંતરાલ પ્રતિનિધિત્વ કરે છે — સંખ્યાઓ માટે (1..10), અક્ષરો માટે ('a'..'z'), વગેરે. રેન્જ ઉપયોગી પદ્ધતિઓ સાથે વસ્તુઓ છે, જેનો ઉપયોગ પુનરાવર્તન, સ્લાઇસિંગ, સભ્યપદ પરીક્ષણ અને case મેળવવા માટે થાય છે. તે 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]
રેન્જ Enumerable શામેલ કરે છે, તેથી તે each, map, select, વગેરે સમર્થન કરે છે — અને to_a તેમને શ્રેણીમાં પરિણમાં કરે છે.
(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? સભ્યપદ કુશળતાપૂર્વક પરીક્ષણ કરે છે (ખાસ કરીને cover?, જે માત્ર અંતબિંદુઓ ચકાસે છે પુનરાવર્તન વિના).
# 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)
રેન્જ Ruby માટે ઉપયોગી, અભિવ્યક્તિશીલ વિશેષતા છે જેનો ઉપયોગ ઘણા સામાન્ય સંજોગોમાં થાય છે, તેથી તેને સમજવું મૂલ્યવાન રોજિંદાનું જ્ઞાન છે.
તે સંક્ષિપ્તપણે અંતરાલો (સંખ્યાત્મક, મૂળાક્ષર) પ્રતિનિધિત્વ કરે છે અને ઘણાં વારંવાર સંજોગોમાં પ્રગટ થાય છે: પુનરાવર્તન ((1..5).each — શ્રેણી પર લૂપ કરવાની સ્વચ્છ રીત), સ્લાઇસિંગ શ્રેણી અને તારઓ (arr[1..3], str[0..4] — આમાં-ક્રમોને કુશળતાપૂર્વક સંપાદિત કરવી), સભ્યપદ પરીક્ષણ (include?/cover? — તપાસવું કે શું મૂલ્ય અંતરાલમાં આવે છે, cover? સાથે ફક્ત અંતબિંદુઓ ચકાસીને કુશળ છે), અને ખાસ કરીને case/when મેળવવી (સ્વચ્છ શ્રેણી-આધારિત શાખાવહન, જેમ કે ગુણવત્તા શ્રેણીઓ દ્વારા ગ્રેડિંગ — એક સામાન્ય, વાચનીય પેટર્ન).
મહત્ત્વપૂર્ણ .. (અનિવાર્ય) વિરુદ્ધ ... (બર્ખાસ્ત) તફાવતને સમજવું રેન્જને સાચી રીતે ઉપયોગ કરવા માટે જરૂરી છે (અને મૂંઝવણનો એક સામાન્ય બિંદુ).
જાણવું કે રેન્જ Enumerable શામેલ કરે છે (તેથી તે map/select/વગેરે સમર્થન કરે છે), પુનરાવર્તન, સ્લાઇસિંગ, સભ્યપદ, અને કેસ મેળવવા માટે તેનો ઉપયોગ કેવી રીતે કરવો, અને આધુનિક વિશેષતાઓ (અનંત/શરૂઆતવાળી રેન્જ) વ્યવહારુ ઉપયોગોને આવરી લે છે.
રેન્જ ઘણી વાર idiomatic Ruby માં પ્રગટ થાય છે (પુનરાવર્તન, સ્લાઇસિંગ, શ્રેણી-આધારિત શરતીયતાઓ, મૂલ્ય શ્રેણીઓની માન્યતા), અને કારણ કે તે અંતરાલો સંભાળવાનો સંક્ષિપ્ત, અભિવ્યક્તિશીલ રીત છે, રેન્જને સમજવું — તેમનો વાક્યરચના (અનિવાર્ય વિરુદ્ધ બર્ખાસ્ત), પદ્ધતિઓ, અને સામાન્ય ઉપયોગો (પુનરાવર્તન, સ્લાઇસિંગ, સભ્યપદ, કેસ મેળવવી) — ઉપયોગી, વ્યવહારુ-સંબંધિત જ્ઞાન છે સ્વચ્છ, idiomatic Ruby લખવા માટે જે ક્રમો અને અંતરાલોને કુશળતાપૂર્વક સંભાળે છે.