Ruby hangi kontrol akışı özelliklerini sunar?

Question

Accepted Answer

Ruby standart kontrol akışını (`if`, `case`, `while`) sunar, ancak ayırt edici ve etkileyici özellikleriyle: **değiştirici formlar** (`do_x if condition`), `unless`, güçlü `case/when`, ve **bloklar aracılığıyla iterasyon** tercihiyle. Ruby'de kontrol akışı doğal okunur.

## Koşullu İfadeler (if, unless, değiştirici 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'nin **değiştirici formu** (`puts "x" if condition`) koşulu sonuna koyarak, kısa ve okunabilir tek satırlık ifadeler oluşturur. **`unless`** (= "eğer değilse") olumsuzluktan daha doğal okunur. Ve `if` bir **ifade**dir ve bir değer döndürür.

## case/when — güçlü desen eşleştirme

```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'nin **`case/when`** güçlüdür — değerleri, aralıkları, türleri ve (Ruby 3'te) yapısal desenleri eşleştirir, arka planda `===` kullanır. Temel bir switch'ten çok daha esnektir.

## Döngüler — ancak iterasyon tercih edilir

```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'de `while`/`until` vardır, ancak idiyomatik Ruby **açık döngülerden ziyade bloklar aracılığıyla iterasyonu tercih eder** (`each`, `times`, `map`) — daha etkileyici ve Ruby tarzıdır.

## Neden önemli

Ruby'nin kontrol akışını anlamak temel günlük bilgidir ve birkaç ayırt edici özellik Ruby'nin etkileyici, okunabilir felsefesini yansıtır.

**Değiştirici form** (`do_x if condition`) ve **`unless`** (= "eğer değilse") kısa, İngilizçe benzeri koşullar yazmanızı sağlar; bunlar idiyomatik Ruby'dir ve her yerde görülür.

**`if` bir ifade olması** (bir değer döndürmesi) zarif atamalar sağlar.

Ruby'nin **`case/when`** önemli ölçüde güçlüdür — değerleri, aralıkları, türleri ve (Ruby 3'te) `===` aracılığıyla yapısal desenleri eşleştirir — bunu temel bir switch'ten çok daha esnek ve temiz çok yönlü dallanma için faydalı yapar.

Kritik olarak, idiyomatik Ruby **geleneksel `for`/`while` döngüleri yerine blok aracılığıyla iterasyonu tercih eder** (`each`, `times`, `map`, `upto`) — bu belirleyici bir stil noktasıdır: Ruby geliştiricileri koleksiyonları ve aralıkları açık döngüler yerine blok tabanlı yöntemlerle itere ederler, bu daha etkileyici ve Ruby tarzıdır.

Bu yapıları ve idiyomları anlamak — okunabilir koşullar için değiştirici form ve `unless`, güçlü `case/when`, ve özellikle **açık döngülerden ziyade blok tabanlı iterasyon tercihini** — idiyomatik Ruby yazmak ve okumak için önemlidir.

Kontrol akışı her programda görüldüğü ve Ruby'nin etkileyici formları (değiştirici formlar, `unless`, güçlü case, blok iterasyonu) okunabilirliğe odaklı felsefesini somutlaştırdığı için, bunlara hakim olmak — diğer dillerden ağır döngü desenleri tercüme etmek yerine doğal, idiyomatik Ruby yazmak için — temel, gerekli bilgidir.