ஒரு Range மதிப்புகளின் இடைவெளியை குறிக்கிறது — (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 பொருத்தம் (சுத்த வரம்பு அடிப்படைய கிளைத்தல், மதிப்பெண் வரம்புகளால் மதிப்பெண் கண்ணளவு செய்தல் போன்றவை — ஒரு பொதுவான, படிக்கக்கூடிய முறை).
சரியாக வரம்புகளைப் பயன்படுத்த .. (உள்படுத்துவது) vs ... (விலக்குவது) மதிப்பிட வேண்டிய வேறுபாடு அவசியம் (மற்றும் குழப்பத்தின் ஒரு பொதுவான புள்ளி).
வரம்புகள் Enumerable-ஐ உள்படுத்துகின்றன என்பதை அறிதல் (எனவே அவை map/select/முதலியவை ஆதரிக்கின்றன), மறு செய்கையிலும் பகுதிகளை எடுத்தலிலும் உறுப்பினர்களிலும் case பொருத்தத்தில் அவற்றை எவ்வாறு பயன்படுத்துவது, மற்றும் நவீன அம்சங்கள் (முடிவிலா/தொடக்கமில்லா வரம்புகள்) சூதுவாணிக்கக்கூடிய பயன்கள் உள்ளடக்கும்.
வரம்புகள் நிலைத்தவ Ruby-ல் அடிக்கடி தோன்றுவதால் (மறு செய்கை, பகுதிகளை எடுத்தல், வரம்பு-அடிப்படைய நிபந்தனைகள், மதிப்பு வரம்புகளின் சரிபார்ப்பு), மற்றும் அவை இடைவெளிகளைக் கையாளுவதற்கான ஒரு சுருக்கமான, வெளிப்பாடு நிறைந்த வழியாக இருப்பதால், வரம்புகளைப் புரிந்துகொள்வது — அவற்றின் தொடரியல் (உள்படுத்துவது vs விலக்குவது), முறைகள், மற்றும் பொதுவான பயன்கள் (மறு செய்கை, பகுதிகளை எடுத்தல், உறுப்பினர், case பொருத்தம்) — சுத்த, நிலைத்தவ Ruby எழுத வேண்டிய பயனுள்ள, நடைமுறை-பொருத்தமான அறிவு ஆகும் அதுவும் வரிசைகள் மற்றும் இடைவெளிகளை நேர்த்தியாக கையாளுகிறது.