Ruby ఏ నియంత్రణ-ప్రవాహ సదుపాయాలను అందిస్తుంది?

Question

Accepted Answer

Ruby ప్రామాణిక నియంత్రణ-ప్రవాహ (`if`, `case`, `while`) ను అందిస్తుంది కానీ విలక్షణమైన, వ్యక్తీకరణ సమృద్ధమైన లక్షణాలతో: **మోడిఫైయర్ రూపాలు** (`do_x if condition`), `unless`, శక్తిమంతమైన `case/when`, మరియు సాంప్రదాయక లూప్‌ల కంటే **బ్లాక్‌ల ద్వారా పునరావృత్తిని** ఇష్టపడటం. Ruby లో నియంత్రణ ప్రవాహం సహజంగా చదవబడుతుంది.

## Conditionals (if, unless, modifier form)

```ruby
if 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/when — శక్తిమంతమైన నమూనా సరిపోలిక

```ruby
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 కంటే చాలా ఎక్కువ సరళమైనది.

## Loops — కానీ పునరావృత్తి ఉత్తమం

```ruby
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 కి బదులుగా ఇతర భాషల నుండి లూప్-భారీ నమూనాలను అనువదించడం పూర్ణ, పునాదిగా రాయడానికి ముఖ్యమైనది.