Ruby ప్రామాణిక నియంత్రణ-ప్రవాహ (if, , ) ను అందిస్తుంది కానీ విలక్షణమైన, వ్యక్తీకరణ సమృద్ధమైన లక్షణాలతో: (), , శక్తిమంతమైన , మరియు సాంప్రదాయక లూప్ల కంటే ఇష్టపడటం. Ruby లో నియంత్రణ ప్రవాహం సహజంగా చదవబడుతుంది.
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 యొక్క మోడిఫైయర్ రూపం (puts "x" if condition) షరతును చివరలో ఉంచుతుంది క్లుప్త, చదవదగిన వన్-లైనర్ల కోసం. unless (= "ఒకవేళ కాదు") నిషేధం కంటే మరింత సహజంగా చదువుతుంది. మరియు if ఒక వ్యక్తీకరణ ఇది విలువను తిరిగి ఇస్తుంది.
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 శక్తిమంతమైనది — ఇది విలువలు, పరిధులు, రకాలు, మరియు (Ruby 3 లో) నిర్మాణాత్మక నమూనాలను సరిపోల్చుతుంది, === ను అంతర్గతంగా ఉపయోగిస్తూ. ప్రాథమిక 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 కలిగి ఉంది, కానీ ఆచారవిధానమైన Ruby స్పష్టమైన లూప్ల కంటే బ్లాక్లతో పునరావృత్తిని ఇష్టపడుతుంది (each, times, map) — మరింత వ్యక్తీకరణ సమృద్ధమైన మరియు Ruby-సదృశ్యమైన.
Ruby యొక్క నియంత్రణ ప్రవాహాన్ని అర్థం చేసుకోవడం ప్రాథమిక రోజువారీ జ్ఞానం, మరియు అనేక విలక్షణమైన లక్షణాలు Ruby యొక్క వ్యక్తీకరణ, చదవదగిన తత్త్వశాస్త్రాన్ని ప్రతిబింబిస్తాయి.
మోడిఫైయర్ రూపం (do_x if condition) మరియు unless (= "ఒకవేళ కాదు") మీరు క్లుప్త, ఆంగ్లంలో సారూప్యమైన నిబంధనలను రాయడానికి అనుమతిస్తాయి ఇవి ఆచారవిధానమైన Ruby మరియు నిరంతరం కనిపిస్తాయి.
if ఒక వ్యక్తీకరణ (విలువను తిరిగి ఇస్తూ) ఎందుకంటే ఇది సుందర నియామకాలను ప్రారంభం చేస్తుంది.
Ruby యొక్క case/when విశేషముగా శక్తిమంతమైనది — విలువలు, పరిధులు, రకాలు, మరియు (Ruby 3 లో) === ద్వారా నిర్మాణాత్మక నమూనాలను సరిపోల్చుతూ — ఇది ప్రాథమిక switch కంటే చాలా ఎక్కువ సరళమైనది మరియు శుభ్ర బహుముఖ శాఖ కోసం ఉపయోగకరమైనది.
ముఖ్యంగా, ఆచారవిధానమైన Ruby సాంప్రదాయక for/while లూప్ల కంటే బ్లాక్లతో పునరావృత్తిని (each, times, map, upto) ఇష్టపడుతుంది — ఇది నిర్ణయించే శైలిపరమైన పాయింట్: Ruby డెవలపర్లు సంગ్రహాలు మరియు పరిధులను బ్లాక్-ఆధారిత పద్ధతులతో పునరావృత్తి చేస్తారు కాకుండా స్పష్టమైన లూప్ల కంటే, ఇది మరింత వ్యక్తీకరణ సమృద్ధమైన మరియు Ruby-సదృశ్యమైనది.
ఈ నిర్మాణాలు మరియు ఆచారాలను అర్థం చేసుకోవడం — చదవదగిన నిబంధనల కోసం మోడిఫైయర్ రూపం మరియు unless, శక్తిమంతమైన case/when, మరియు ముఖ్యంగా స్పష్టమైన లూప్ల కంటే బ్లాక్-ఆధారిత పునరావృత్తికి ఆదరణ — ఆచారవిధానమైన Ruby ను రాయడానికి మరియు చదవడానికి ముఖ్యమైనది.
నియంత్రణ ప్రవాహం ప్రతి ప్రోగ్రామ్లో కనిపిస్తుంది కాబట్టి, మరియు Ruby యొక్క వ్యక్తీకరణ రూపాలు (మోడిఫైయర్లు, unless, శక్తిమంతమైన case, బ్లాక్ పునరావృత్తి) దాని చదవదగిన-కేంద్రీకృత తత్త్వశాస్త్రాన్ని కలిగి ఉన్నాయి, వాటిని ప్రావీణ్యం చేయడం సహజమైన, ఆచారవిధానమైన Ruby కి బదులుగా ఇతర భాషల నుండి లూప్-భారీ నమూనాలను అనువదించడం పూర్ణ, పునాదిగా రాయడానికి ముఖ్యమైనది.