Ruby પ્રમાણભૂત control-flow (if, , ) આપે છે પરંતુ વિશિષ્ટ, અભિવ્યક્તિશીલ વৈશિષ્ટ્યો સાથે: (), , શક્તિશાળી , અને traditional loops કના બદલે ની પસંદગી. Ruby માં control flow કુદરતી રીતે વાંચાય છે.
casewhiledo_x if conditionunlesscase/whenif age >= 18
puts "adult"
elsif age >= 13
puts "teen"
else
puts "child"
end
# MODIFIER form — condition at the END (reads like English, idiomatic for short cases)
puts "adult" if age >= 18
puts "minor" unless age >= 18 # `unless` = if not (more readable than `if !`)
# everything is an expression — if returns a value
grade = if score >= 90 then "A" else "B" end
Ruby નું modifier form (puts "x" if condition) શરત ને અંતે મૂકે છે સંક્ષિપ્ત, વાંચનીય one-liners માટે. unless (= "if not") નકારાત્મતા કંటાળ વધુ કુદરતી રીતે વાંચાય છે. અને if એક expression છે જે એક મૂલ્ય આપે છે.
case status
when :active then "running"
when :stopped, :paused then "halted" # multiple values
when 1..10 then "small number" # ranges
when String then "it's a string" # types (uses ===)
else "unknown"
end
# case can also do structural pattern matching (Ruby 3)
case data
in { name: String => name, age: Integer } # pattern matching with destructuring
puts name
end
Ruby નું case/when શક્તિશાળી છે — તે મૂલ્યો, ranges, પ્રકારો, અને (Ruby 3 માં) structural patterns ને મેળ ખાય છે, hood હેઠળ === નો ઉપયોગ કરીને. મૂળભૂત switch કંટાળ વધુ લવચીક છે.
while count < 10 do count += 1 end
until done do ... end # until = while not
# ✅ but Ruby PREFERS iteration with blocks over explicit loops:
5.times { |i| puts i } # instead of a for loop
[1, 2, 3].each { |n| puts n } # iterate a collection
(1..10).each { |n| ... } # iterate a range
1.upto(5) { |i| ... }
Ruby માં while/until છે, પણ idiomatic Ruby explicit loops કના બદલે blocks સાથે iteration (each, times, map) ને પ્રાધાન્ય આપે છે — વધુ અભિવ્યક્તિશીલ અને Ruby-જેવું.
Ruby નું control flow સમજવું મૌલિક દૈનિક જ્ઞાન છે, અને ઘણી વિશિષ્ટ વૈશિષ્ટ્યો Ruby ના અભિવ્યક્તિશીલ, વાંચનીય દર્શન પ્રતિબિંબિત કરે છે.
Modifier form (do_x if condition) અને unless (= "if not") તમને સંક્ષિપ્ત, અંગ્રેજી-જેવી શરતીતા લખવા દે છે જે idiomatic Ruby છે અને સતત દેખાય છે.
તથ્ય એ છે કે if એક expression છે (મૂલ્ય આપતું) elegant assignments સક્ષમ કરે છે.
Ruby નું case/when નોંધપાત્રપણે શક્તિશાળી છે — મૂલ્યો, ranges, પ્રકારો, અને (Ruby 3 માં) === દ્વારા structural patterns ને મેળ ખાય છે — તેને મૂળભૂત switch કંટાળ વધુ લવચીક બનાવે છે અને સ્વચ્છ multi-way branching માટે ઉપયોગી છે.
મહત્વપૂર્ણ રીતે, idiomatic Ruby traditional for/while loops કના બદલે blocks સાથે iteration (each, times, map, upto) ને પ્રાધાન્ય આપે છે — આ એક સીમાંકિત શૈલીની બાબત છે: Ruby વિકાસકર્તાઓ collections અને ranges ને block-આધારિત પદ્ધતિઓ સાથે iterate કરે છે explicit loops ની જગાએ, જે વધુ અભિવ્યક્તિશીલ અને Ruby-જેવું છે.
आ constructs અને idioms સમજવું — modifier form અને unless વાંચનીય શરતીતા માટે, શક્તિશાળી case/when, અને ખાસ કરીને explicit loops કના બદલે block-આધારિત iteration ના પ્રતિ પસંદગી — idiomatic Ruby લખવા અને વાંચવા માટે મહત્વપૂર્ણ છે.
ચાલતો કે control flow દરેક પ્રોગ્રામમાં દેખાય છે, અને Ruby ના અભિવ્યક્તિશીલ સ્વરૂપો (modifiers, unless, શક્તિશાળી case, block iteration) તેના readability-કેન્દ્રિત દર્શન ને મૂર્તિમાન કરે છે, તેમને માસ્ટર કરવું આવશ્યક છે, idiomatic Ruby ને કુદરતી રીતે લખવા માટે મૌલિક જ્ઞાન, અન્ય ભાષાઓ પાસેથી loop-heavy patterns અનુવાદ કરવાની જગાએ.