A Range ਮੁੱਲਾਂ ਦਾ ਇੱਕ ਅੰਤਰਾਲ (interval) ਦਰਸਾਉਂਦਾ ਹੈ — ਸੰਖਿਆਵਾਂ ਲਈ (1..10), ਅੱਖਰਾਂ ਲਈ ('a'..'z') ਆਦਿ। ਰੇਂਜ ਆਬਜੈਕਟ ਹਨ ਜਿਹਨਾਂ ਵਿੱਚ ਉਪਯੋਗੀ ਤਰੀਕੇ (methods) ਹਨ, ਮੁੜ ਵਾਰ ਚੱਲਣਾ (iteration), ਸਲਾਈਸਿੰਗ, ਮੈਂਬਰਸ਼ਿਪ ਟੈਸਟਿੰਗ, ਅਤੇ 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 ਉਹਨਾਂ ਨੂੰ ਇੱਕ 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? ਮੈਂਬਰਸ਼ਿਪ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪੀੜ ਕਰਦੇ ਹਨ (ਖਾਸ ਕਰਕੇ 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 — ਇੱਕ ਕ੍ਰਮ ਨੂੰ ਲੂਪ ਕਰਨ ਦਾ ਸਾਫ਼ ਤਰੀਕਾ), ਸਲਾਈਸਿੰਗ arrays ਅਤੇ strings (arr[1..3], str[0..4] — ਸਬ-sequences ਨੂੰ ਸੁੰਦਰ ਤਰੀਕੇ ਨਾਲ ਨਿਕਾਲਣਾ), ਮੈਂਬਰਸ਼ਿਪ ਟੈਸਟਿੰਗ (include?/cover? — ਜਾਂਚਣਾ ਕਿ ਕਿਸੇ ਮੁੱਲ ਦਾ ਪਤਾ ਅੰਤਰਾਲ ਵਿੱਚ ਪੜਦਾ ਹੈ, cover? ਕੁਸ਼ਲ ਹੋ ਕੇ ਸਿਰਫ਼ ਅੰਤਬਿੰਦੂਆਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹਨ), ਅਤੇ ਖਾਸ ਕਰਕੇ case/when ਮੈਚਿੰਗ (ਸਾਫ਼ ਸੀਮਾ-ਆਧਾਰਿਤ ਸ਼ਾਖਾ ਬਣਾਉਣਾ, ਜਿਵੇਂ ਸਕੋਰ ਸੀਮਾਵਾਂ ਦੁਆਰਾ ਗ੍ਰੇਡਿੰਗ — ਇੱਕ ਆਮ, ਪੜ੍ਹਨ ਯੋਗ ਪੈਟਰਨ)।
ਮਹੱਤਵਪੂਰਣ .. (ਸ਼ਾਮਲ) ਬਨਾਮ ... (ਬਾਹਰ ਕੱਢਿਆ ਹੋਇਆ) ਫਰਕ ਨੂੰ ਸਮਝਣਾ ਰੇਂਜ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਵਰਤਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ (ਅਤੇ ਉਲਝਨ ਦਾ ਇੱਕ ਆਮ ਨੁਕਤਾ)।
yah ਜਾਣਨਾ ਕਿ ਰੇਂਜ ਵਿੱਚ Enumerable ਸ਼ਾਮਲ ਹੈ (ਇਸ ਲਈ map/select/ਆਦਿ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ), ਉਹਨਾਂ ਨੂੰ ਮੁੜ ਵਾਰ ਚੱਲਣ, ਸਲਾਈਸਿੰਗ, ਮੈਂਬਰਸ਼ਿਪ, ਅਤੇ ਕੇਸ ਮੈਚਿੰਗ ਲਈ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ, ਅਤੇ ਆਧੁਨਿਕ ਫਿਚਰ (ਅੰਤਹੀਨ/ਸ਼ੁਰੂ ਰਹਿਤ ਰੇਂਜ) ਵਿਹਾਰਕ ਉਪਯੋਗ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ।
new ਕਿਉਂਕਿ ਰੇਂਜ idiomatic Ruby ਵਿੱਚ ਅਕਸਰ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ (ਮੁੜ ਵਾਰ ਚੱਲਣਾ, ਸਲਾਈਸਿੰਗ, ਸੀਮਾ-ਅਧਾਰਿਤ ਸ਼ਰਤੀ, ਮੁੱਲ ਸੀਮਾਵਾਂ ਦੀ ਪੁਸ਼ਟਿ), ਅਤੇ ਕਿਉਂਕਿ ਉਹ ਅੰਤਰਾਲ ਨੂੰ ਸੰਭਾਲਣ ਦਾ ਇੱਕ ਸੰਖੇਪ, ਸਮੀਕਰਣ ਪ੍ਰਿਛਿਆਦੀ ਤਰੀਕਾ ਹਨ, ਰੇਂਜ ਨੂੰ ਸਮਝਣਾ — ਉਹਨਾਂ ਦੀ syntax (ਸ਼ਾਮਲ ਬਨਾਮ ਬਾਹਰ ਕੱਢਿਆ ਹੋਇਆ), ਤਰੀਕੇ, ਅਤੇ ਆਮ ਉਪਯੋਗ (ਮੁੜ ਵਾਰ ਚੱਲਣਾ, ਸਲਾਈਸਿੰਗ, ਮੈਂਬਰਸ਼ਿਪ, ਕੇਸ ਮੈਚਿੰਗ) — ਸਫ਼ਾਈ, idiomatic Ruby ਲਿਖਣ ਲਈ ਉਪਯੋਗੀ, ਵਿਹਾਰਕ-ਪ੍ਰਾਸੰਗਿਕ ਜਾਣਕਾਰੀ ਹੈ ਜੋ ਤਰਤੀਬਾਂ ਅਤੇ ਅੰਤਰਾਲ ਨੂੰ ਸੁੰਦਰ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ।