Wace irin control-flow ne Ruby ke bayarwa?

Question

Accepted Answer

Ruby tana bayarwa da daidaitaccen control-flow (`if`, `case`, `while`) amma tare da ingantattun, mahimman fasalai: **sifofin gyara** (`do_x if condition`), `unless`, m mahimmar `case/when`, da fifita ga **juyawa ta hanyar blocks** a maimakon bukatar tsofaffi. Control flow a Ruby suna karantawa da kyau.

## Abubuwan sharati (if, unless, sifar gyara)

```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 **sifar gyara** (`puts "x" if condition`) tana sanya sharati a gefen aro don kawai, karancin jajere. **`unless`** (= "idan ba") tana karantawa mafi kyau fiye da wariya. Kuma `if` shine **jajere** wanda ke dawo da kari.

## case/when — mahimmar daidaitawa da alamu

```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`** yana ikon - tana daidaitawa da kiyayya, jeri, nau'i, da (a Ruby 3) tsarin alamu, tana amfani da `===` ƙarƙashin. Mafi girma fiye da waje na sakakakke.

## Juya - amma juyawa ana fifita

```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 tana da `while`/`until`, amma Ruby na yau da kullun **yana fifita juyawa tare da blocks** (`each`, `times`, `map`) a maimakon sakamako na fayyace - mafi girma da ruby-like.

## Me ya sa ya mahalaka

Tunawa da control flow na Ruby shine muhimmin ilimi na kullun, kuma wasu ingantattun fasalai sun nuna Ruby ta fahimtar, karantawa ta tunanin.

**Sifar gyara** (`do_x if condition`) da **`unless`** (= "idan ba") suna ba da dama ka rubuta kawai, jajere na Ingilishi wanda ke rufe ruby da suna bayyana a kullun.

Gaskiya cewa **`if` shine jajere** (dawo da kari) yana ba da dama ga kyakkyawan abubuwan nuni.

Ruby **`case/when`** shine mahimmi - daidaitawa da kiyayya, jeri, nau'i, da (a Ruby 3) tsarin alamu ta hanyar `===` - tana ba da dama mafi girma fiye da waje na sakakakke kuma tana aiki da tsafi mai cikakke.

Da kaifi, ruby ta yau da kullun **yana fifita juyawa tare da blocks** (`each`, `times`, `map`, `upto`) a maimakon bukatar `for`/`while` - wannan shine mahimmar siyasar hanya: Ruby masu shin juyawa junaɗa da jeri tare da hanyoyin da ke da block maimakon sakamako na fayyace, wanda yana da kari da ruby-like.

Tunawa da waɗannan abubuwan da ilimin - sifar gyara da `unless` don jajeren da ake bukata, mahimmar `case/when`, da musamman **fifita don block-based juyawa a maimakon sakamako na fayyace** - shine mahimmi don rubuta da karantawa da idiomatic ruby.

Domin control flow suna bayyana a cikin kowane shiri, kuma domin Ruby ta mahimmar fuska (sifofin gyara, `unless`, mahimmar case, juyawa ta hanyar block) suna nuna tunaninta da karancin tunanin, shakanin su shine muhimmin, ilimin tushe don rubuta ruby ta dace, ruby-like maimakon juyawa sifofin bukatar daga sauran harsunuka.