Ruby'de Kontrol Akışı Mekanizmaları ve Kapsamlı Kullanım Rehberi

LydexCoding · 13 Ağu 2025

Giriş: Programlamanın Kalbi Kontrol Akışı
Programlamada kontrol akışı, kodunuzun hangi sırayla çalışacağını belirleyen temel bir kavramdır. Bu, uygulamanızın belirli koşullara göre farklı yollar izlemesini, belirli işlemleri tekrarlamasını veya beklenmedik durumları (hataları) yönetmesini sağlayan mekanizmalar bütünüdür. Ruby gibi dinamik ve esnek bir dilde, geliştiricilere bu akışı yönetmek için zengin ve çeşitli yapılar sunulur. Bu makalede, Ruby'deki başlıca kontrol akışı mekanizmalarını derinlemesine inceleyecek, her biri için açıklayıcı örnekler sunacak ve pratik kullanım senaryolarına değineceğiz. Amacımız, Ruby kodunuzu daha okunabilir, sürdürülebilir ve hataya dayanıklı hale getirmek için bu yapıları nasıl etkili bir şekilde kullanabileceğinizi göstermektir.

1. Koşullu İfadeler: Karar Vermenin Temeli
Koşullu ifadeler, bir veya daha fazla koşulun doğru (truthy) olup olmadığına bağlı olarak farklı kod bloklarının yürütülmesini sağlar. Ruby'de `nil` ve `false` dışındaki tüm değerler 'truthy' olarak kabul edilir, bu da boş string'lerin, sıfır sayısının veya boş dizilerin bile koşullu ifadelerde `true` olarak değerlendirileceği anlamına gelir.

if/elsif/else
Ruby'de en sık kullanılan ve en temel koşullu yapıdır. Bir koşul doğruysa belirli bir kod bloğunu çalıştırır; aksi takdirde `elsif` ile diğer koşullar kontrol edilir, ve hiçbir koşul doğru değilse `else` bloğu yürütülür.

Kod:

    # Basit bir if-else yapısı
    yas = 20
    if yas >= 18
      puts "Reşitsiniz ve oy kullanabilirsiniz."
    else
      puts "Henüz reşit değilsiniz."
    end

    # if-elsif-else kullanımı
    hava_durumu = "bulutlu"
    if hava_durumu == "güneşli"
      puts "Bugün dışarıda piknik yapabiliriz!"
    elsif hava_durumu == "yağmurlu"
      puts "Şemsiyeni almayı unutma ve kapalı mekan aktiviteleri planla."
    elsif hava_durumu == "bulutlu"
      puts "Hava biraz kapalı ama yine de yürüyüş yapılabilir."
    else
      puts "Hava durumu hakkında bilgi yok veya beklenmedik bir durum."
    end

    # Tek satırlık (modifier) if kullanımı: Koşul sağlandığında ifadeyi yürütür.
    # Bu kullanım, basit koşullar için kod okunabilirliğini artırır.
    sicaklik = 28
    puts "Sıcaklık 25 derecenin üzerinde, serinletici içecekler iyi gider!" if sicaklik > 25

İpucu: Tek satırlık `if` ifadeleri, kısa ve net koşullar için oldukça kullanışlıdır. Ancak, birden fazla ifade içeren veya daha karmaşık mantığa sahip durumlarda tam `if...end` bloğu tercih edilmelidir.

unless
`if` ifadesinin tam zıttı işlev görür: belirtilen koşul yanlışsa (false veya nil) kod bloğunu çalıştırır. Bazen `if not` yazmaktan daha okunabilir kabul edilir.
Kod:
```
    # Basit bir unless kullanımı
    is_admin = false
    unless is_admin
      puts "Yönetici yetkileri gerekli, erişim reddedildi."
    end

    # Tek satırlık (modifier) unless kullanımı
    gelir = 1500
    puts "Vergi mükellefi değilsiniz." unless gelir >= 2000
```
Uyarı: `unless` yapısı, özellikle birden fazla `elsif` gerektiren durumlarda karmaşıklaşabilir. Bu tür senaryolarda `if` kullanmak veya `case` ifadesine geçmek daha uygun olabilir.

case/when
Birden fazla `elsif` koşulu yerine daha okunabilir ve yapılandırılmış bir alternatif sunar. Belirli bir değerin çeşitli olası durumlarını kontrol etmek için idealdir. Özellikle bir değişkenin farklı değerlerine göre farklı eylemler yapmak gerektiğinde kullanılır.

Kod:

    # Bir değişkenin değerine göre case/when kullanımı
    meyve = "elma"
    case meyve
    when "elma"
      puts "Bu bir elma, vitamin deposu."
    when "muz", "çilek" # Birden fazla değer için aynı when bloğu
      puts "Bu bir muz veya çilek, yaz meyvesi."
    when "portakal"
      puts "Bu bir portakal, C vitamini kaynağı."
    else
      puts "Bilinmeyen bir meyve türü."
    end

    # case ifadesinin bir argüman almadan kullanımı (koşullu bir when ifadesi gibi)
    # Bu durumda, her when bloğu kendi koşulunu değerlendirir ve ilk doğru olan çalışır.
    puan = 85
    case
    when puan >= 90
      puts "Notunuz: A - Mükemmel"
    when puan >= 80
      puts "Notunuz: B - Çok İyi"
    when puan >= 70
      puts "Notunuz: C - İyi"
    when puan >= 60
      puts "Notunuz: D - Geçer"
    else
      puts "Notunuz: F - Başarısız"
    end

Ruby topluluğunda, çok sayıda `elsif` içeren uzun `if/elsif/else` blokları yerine `case/when` kullanımı genellikle daha idiomatik ve kod okunabilirliğini artıran bir yaklaşımdır.

2. Döngüler: Tekrarlayan Görevleri Yönetmek
Döngüler, belirli bir kod bloğunu bir koşul doğru olduğu sürece veya belirli bir koleksiyonun her öğesi için tekrarlamak amacıyla kullanılır. Ruby, farklı senaryolar için çeşitli döngü yapıları sunar.

while
Bir koşul doğru olduğu sürece kod bloğunu çalıştırır. Döngüye girmeden önce koşulu kontrol eder ve koşul yanlış olduğunda döngü sona erer.
Kod:
```
    sayac = 0
    while sayac < 5
      puts "While döngüsü: #{sayac}"
      sayac += 1
    end
    puts "While döngüsü bitti."
```
until
`while` döngüsünün zıttıdır; koşul yanlış olduğu sürece kod bloğunu çalıştırır. Koşul doğru olduğunda döngü sona erer.
Kod:
```
    sayac = 0
    until sayac == 5
      puts "Until döngüsü: #{sayac}"
      sayac += 1
    end
    puts "Until döngüsü bitti."
```
for
Belirli bir aralık veya koleksiyon üzerindeki her öğe için iterasyon yapar. Diğer dillerdeki `for` döngülerine benzer olsa da, Ruby'de koleksiyonlar üzerinde iterasyon için genellikle `each` metodu daha çok tercih edilir.
Kod:
```
    # Sayı aralığı üzerinde iterasyon
    for i in 0..4
      puts "For döngüsü, sayı: #{i}"
    end

    # Dizi (Array) üzerinde iterasyon
    meyveler = ["elma", "muz", "kiraz"]
    for meyve in meyveler
      puts "Bu bir #{meyve}."
    end
```
Not: `for` döngüsü kullanıldığında, döngü değişkeni (yukarıdaki örnekte `i` veya `meyve`) döngü bittikten sonra bile dış kapsamda erişilebilir kalır. Bu durum, `each` metodundan farklıdır ve bazen istenmeyen yan etkilere yol açabilir.

each (Iteratörler)
Ruby'nin en 'Rubyvari' döngü mekanizmasıdır. Diziler, hash'ler ve diğer koleksiyonlar üzerinde iterasyon yapmak için kullanılır ve `Enumerable` modülü tarafından sağlanır. Ruby'de döngüler için tercih edilen yaklaşımdır.

Kod:

    # Dizi üzerinde each ile iterasyon
    sayilar = [1, 2, 3, 4, 5]
    sayilar.each do |sayi|
      puts "Each döngüsü, sayı: #{sayi}"
    end

    # Hash üzerinde each ile iterasyon (anahtar-değer çiftleri)
    kisiler = { "Ali" => 30, "Ayşe" => 25, "Can" => 35 }
    kisiler.each do |ad, yas|
      puts "#{ad} #{yas} yaşında."
    end

    # Farklı each variantları: each_with_index (indeks ile birlikte)
    meyveler.each_with_index do |meyve, indeks|
      puts "#{indeks + 1}. meyve: #{meyve}"
    end

Fark: `each` metoduyla kullanılan blok değişkenleri (`|sayi|`, `|ad, yas|`), blok dışında erişilemez. Bu, değişken kapsamı açısından daha güvenli bir yaklaşımdır.

loop
Sonsuz bir döngü oluşturmak için kullanılır. Özellikle bir koşulun döngünün içinden belirlendiği ve `break` ifadesiyle açıkça sonlandırılması gereken durumlarda faydalıdır.

Kod:

    loop do
      puts "Sonsuz döngüden çıkmak için 'çık' yazın:"
      giris = gets.chomp.downcase
      if giris == "çık"
        puts "Döngüden çıkılıyor..."
        break # Döngüyü sonlandırır
      else
        puts "Geçersiz giriş: #{giris}. Tekrar deneyin."
      end
    end
    puts "Döngü sona erdi."

3. Döngü Kontrol Anahtar Kelimeleri: İterasyonları Yönlendirmek
Döngülerin içinde özel davranışlar sergilemek, iterasyonları belirli koşullara göre atlamak veya tamamen sonlandırmak için bu anahtar kelimeler kullanılır.

break
Döngüyü hemen sonlandırır ve program akışını döngüden sonraki ilk koda taşır. En yaygın döngü kontrol kelimesidir.

Kod:

    sayac = 0
    while true # Sonsuz döngü başlat
      puts "Sayac: #{sayac}"
      sayac += 1
      if sayac > 3
        break # Eğer sayac 3'ü geçerse döngüyü kır
      end
    end
    puts "Döngü 'break' ile kırıldı."

next
Mevcut iterasyonu atlar ve döngünün bir sonraki iterasyonuna geçer. Özellikle belirli koşulları sağlayan öğeleri işlemek veya belirli öğeleri göz ardı etmek istediğinizde kullanışlıdır.
Kod:
```
    sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    sayilar.each do |sayi|
      next if sayi.even? # Eğer sayı çift ise, bu iterasyonu atla
      puts "Tek sayı bulundu: #{sayi}"
    end
```

redo
Mevcut iterasyonu yeniden başlatır, ancak döngü koşulunu tekrar kontrol etmeden. Bu, özellikle bir kullanıcıdan geçerli girdi alınana kadar aynı döngü iterasyonunu tekrar denemek gibi nadir durumlarda kullanılır.

Kod:

    input_attempts = 0
    loop do
      print "Bir sayı girin (1-5): "
      giris = gets.chomp
      input_attempts += 1

      if giris =~ /^[1-5]$/ # Girdinin 1-5 arasında bir sayı olup olmadığını kontrol et
        puts "Geçerli sayı: #{giris}"
        break
      else
        puts "Geçersiz giriş! Lütfen 1 ile 5 arasında bir sayı girin."
        redo if input_attempts < 3 # İlk 3 denemede tekrar dene
        puts "Çok fazla hatalı deneme. Program sonlandırılıyor."
        break
      end
    end

Uyarı: `redo` kullanımı dikkat gerektirir ve sonsuz döngü riskini önlemek için bir kontrol mekanizması (örneğin deneme sayacı) ile birlikte kullanılmalıdır. Oldukça nadir kullanılan bir anahtar kelimedir.

4. Hata Yönetimi (Exception Handling): Beklenmedik Durumlarla Başa Çıkmak
Ruby'de hatalar (exceptions), programın beklenmedik durumlarla karşılaşması durumunda ortaya çıkar. Bu hataları yakalamak, programın çökmesini önlemek ve zarif bir şekilde kurtarma işlemleri yapmak için özel yapılar kullanılır.

begin/rescue/else/ensure
Bu bloklar, potansiyel olarak hata fırlatabilecek kodları sarmak ve bu hataları yönetmek için kullanılır.

Kod:

    def bolme(bolunen, bolen)
      begin
        sonuc = bolunen / bolen
      rescue ZeroDivisionError => e # Sıfıra bölme hatasını yakala
        puts "Hata oluştu: Sıfıra bölme yapılamaz! Detay: #{e.message}"
        return nil
      rescue TypeError => e # Tip uyuşmazlığı hatasını yakala (örneğin string ile bölme)
        puts "Hata oluştu: Sayısal olmayan değerlerle işlem yapılamaz! Detay: #{e.message}"
        return nil
      rescue => e # Yakalanmayan diğer tüm hatalar için genel bir yakalama
        puts "Beklenmedik bir hata meydana geldi: #{e.class} - #{e.message}"
        return nil
      else
        # Hiçbir hata fırlatılmazsa bu blok çalışır
        puts "Bölme işlemi başarıyla tamamlandı, sonuç geçerli."
        return sonuc
      ensure
        # Hata olsun veya olmasın, bu blok her zaman çalışır
        puts "Bölme işlemi denemesi sonlandı."
      end
    end

    puts "\n--- Örnek 1: Başarılı Bölme ---"
    puts "Sonuç: #{bolme(10, 2)}"

    puts "\n--- Örnek 2: Sıfıra Bölme Hatası ---"
    puts "Sonuç: #{bolme(10, 0)}"

    puts "\n--- Örnek 3: Tip Hatası ---"
    puts "Sonuç: #{bolme(10, 'iki')}"

    puts "\n--- Örnek 4: Genel Hata Yakalama ---"
    # Örnek olarak, tanımlanmamış bir metod çağıralım (NameError)
    begin
      undefined_method_call
    rescue => e
      puts "Genel hata yakalandı: #{e.class} - #{e.message}"
    end

* `begin`: Potansiyel olarak hata fırlatabilecek kod bloğunu tanımlar.
* `rescue`: `begin` bloğunda bir hata oluştuğunda bu blok çalışır. Belirli hata türleri yakalanabilir ve hata nesnesine erişim sağlanabilir (`=> e`).
* `else`: `begin` bloğunda hiçbir hata fırlatılmazsa bu blok çalışır. Bu, normal işlem akışının bir parçası olarak düşünülebilir.
* `ensure`: Hata olsun veya olmasın, `begin` bloğu çalıştırıldıktan sonra her zaman çalışacak kodları içerir. Genellikle kaynakları kapatma (dosya, veritabanı bağlantısı vb.) veya temizleme işlemleri için kullanılır.

retry (Hata Yönetiminde Kullanım)
`retry` anahtar kelimesi, `rescue` bloğu içinde kullanıldığında `begin` bloğunu en baştan tekrar çalıştırmayı dener. Özellikle geçici ağ hataları, veritabanı bağlantısı sorunları veya kaynak kilitlenmeleri gibi durumlarda, belirli bir sayıda deneme yapmak için faydalıdır.

Kod:

    deneme_sayisi = 0
    max_deneme = 3

    begin
      deneme_sayisi += 1
      puts "Veritabanına bağlanılıyor... (Deneme #{deneme_sayisi}/#{max_deneme})"

      # Simüle edilmiş bir hata durumu: İlk iki denemede hata fırlat
      raise "Veritabanı bağlantısı kurulamadı!" if deneme_sayisi <= 2

      puts "Veritabanı bağlantısı başarılı!"
      # Başarılı bağlantıdan sonraki işlemler...

    rescue RuntimeError => e # Simüle ettiğimiz hatayı yakala
      puts "Hata oluştu: #{e.message}"
      if deneme_sayisi < max_deneme
        puts "Yeniden deneniyor... (1 saniye bekleniyor)"
        sleep 1 # Yeniden denemeden önce kısa bir bekleme
        retry # begin bloğunu tekrar dene
      else
        puts "Maksimum deneme sayısına ulaşıldı, bağlantı kurulamadı."
        # Hata loglama veya kullanıcıya bildirme gibi son işlemler
      end
    rescue => e_genel
      puts "Beklenmedik bir hata: #{e_genel.class} - #{e_genel.message}"
    end

Önemli Uyarı: `retry` kullanırken, sonsuz bir döngüye düşmemek için her zaman bir deneme sayacı veya benzeri bir mekanizma ile sınırlama getirmek hayati öneme sahiptir.

5. Kısa Devre Mantığı (Short-Circuit Evaluation): Verimli Mantıksal İşlemler
Ruby'deki `&&` (mantıksal VE) ve `||` (mantıksal VEYA) operatörleri, ifadelerin yalnızca gerektiğinde değerlendirilmesini sağlayan kısa devre mantığı kullanır. Bu, hem performansı artırır hem de bazı yaygın programlama desenlerinde kodun daha özlü yazılmasına olanak tanır.

&& (Mantıksal VE)
Eğer ilk operand yanlış (false veya nil) ise, ikinci operand değerlendirilmez çünkü sonuç zaten `false` olacaktır. Bu özellik, bir değişkenin varlığını kontrol edip ardından onun üzerinde bir işlem yapmak gibi durumlarda çok kullanışlıdır.

Kod:

    kullanici_girisi = nil
    # kullanici_girisi nil olduğu için .strip metodu çağrılmaz, hata önlenir.
    kullanici_adi = kullanici_girisi && kullanici_girisi.strip
    puts "Kullanıcı Adı (nil): #{kullanici_adi.inspect}" # => nil

    kullanici_girisi = "  Ayşe  "
    # kullanici_girisi truthy olduğu için .strip metodu çağrılır.
    kullanici_adi = kullanici_girisi && kullanici_girisi.strip
    puts "Kullanıcı Adı (temizlenmiş): #{kullanici_adi.inspect}" # => "Ayşe"

    isAdmin = true
    hasPermission = false
    if isAdmin && hasPermission
      puts "Yönetici ve izne sahip."
    else
      puts "Erişim reddedildi. (hasPermission kontrol edilmez, isAdmin false ise)"
    end

|| (Mantıksal VEYA)
Eğer ilk operand doğru (truthy) ise, ikinci operand değerlendirilmez çünkü sonuç zaten `true` olacaktır. Bu operatör genellikle varsayılan değerler atamak için kullanılır.

Kod:

    tercih_edilen_renk = nil
    varsayilan_renk = "mavi"
    # tercih_edilen_renk nil olduğu için varsayilan_renk atanır.
    secilen_renk = tercih_edilen_renk || varsayilan_renk
    puts "Seçilen Renk (varsayılan): #{secilen_renk}" # => "mavi"

    tercih_edilen_renk = "kırmızı"
    # tercih_edilen_renk truthy olduğu için varsayilan_renk değerlendirilmez.
    secilen_renk = tercih_edilen_renk || varsayilan_renk
    puts "Seçilen Renk (tercih edilen): #{secilen_renk}" # => "kırmızı"

    kullanici_ayar = false # boolean false bile olsa truthy olmayan bir değerdir
    default_ayar = true
    final_ayar = kullanici_ayar || default_ayar
    puts "Final Ayar: #{final_ayar}" # => true (kullanici_ayar false olduğu için default_ayar kullanılır)

6. Diğer Kontrol Akışı Mekanizmaları
Ruby, spesifik ihtiyaçlar için daha az yaygın ancak güçlü kontrol akışı araçları da sunar.

Ternary Operatör (`? :`)
Basit `if/else` ifadelerinin tek satırlık, kompakt bir versiyonudur. Özellikle değişkenlere koşullu olarak değer atamak için kullanılır.
Kod:
```
    yas = 22
    durum = (yas >= 18) ? "Yetişkin" : "Çocuk"
    puts "Durum: #{durum}" # => Yetişkin

    mesaj = (sicaklik > 25) ? "Hava sıcak" : "Hava normal veya serin"
    puts "Mesaj: #{mesaj}"
```
İpucu: Ternary operatör, kodunuzu daha kısa hale getirse de, okunabilirliği karmaşıklaştırmamak adına yalnızca çok basit koşullarda kullanılması önerilir.

throw/catch
Hata yönetimi mekanizmasından farklı olarak, `throw` ve `catch` ifadeleri, iç içe geçmiş kod bloklarından veya metod çağrılarından hızlıca çıkmak için kullanılır. Daha çok, belirli bir duruma ulaşıldığında derin bir çağrı yığınından çıkmak istendiğinde tercih edilir.

Kod:

    def derin_arama_fonksiyonu(aranan_sayi)
      catch :arama_bitir do |tag|
        (1..10).each do |dis_sayi|
          (1..10).each do |ic_sayi|
            toplam = dis_sayi + ic_sayi
            puts "Şu anki toplam: #{toplam}"
            if toplam == aranan_sayi
              # 'arama_bitir' etiketine atla ve ikinci argümanı (toplam) döndür
              throw :arama_bitir, "Hedef toplam (#{toplam}) bulundu: #{dis_sayi} + #{ic_sayi}"
            end
            # Eğer 200'ü geçersek, başka bir çıkış noktası deneyelim
            if toplam > 15 && dis_sayi == 7
                throw :arama_bitir, "Limit aşıldı ve çıkış yapılıyor."
            end
          end
        end
        "Hedef toplam (#{aranan_sayi}) bulunamadı."
      end
    end

    puts "\n--- Örnek 1: Hedef Bulundu ---"
    puts derin_arama_fonksiyonu(10)

    puts "\n--- Örnek 2: Limit Aşıldı ---"
    puts derin_arama_fonksiyonu(25) # Bu, iç döngüden 'limit aşıldı' ile çıkacak

    puts "\n--- Örnek 3: Hedef Bulunamadı ---"
    puts derin_arama_fonksiyonu(100) # Bu hiçbir throw'a denk gelmeyecek

Not: `throw/catch` ikilisi genellikle programın olağan akışında beklenmeyen, ancak programın kendisinin hata olarak kabul etmediği özel durumlar için kullanılır. Klasik hata yönetimi (`begin/rescue`) yerine, bir metod çağrı yığını içinden belirli bir noktaya atlamak için tasarlanmıştır.

Sonuç: Ruby'de Güçlü Kontrol Akışı Yönetimi
Ruby, geliştiricilere esnek ve güçlü kontrol akışı mekanizmaları sunar. `if/elsif/else`, `unless` ve `case` gibi koşullu ifadeler, kodunuzun farklı senaryolara göre dallanmasını ve akıllı kararlar almasını sağlar. `while`, `until`, `for`, `each` ve `loop` gibi döngüler, tekrarlayan görevleri yönetmek için çeşitli seçenekler sunar. `break`, `next`, `redo` ve `retry` gibi anahtar kelimeler, döngülerin ve hata yönetiminin davranışını ince ayar yapmaya olanak tanır. Son olarak, `begin/rescue/else/ensure` mekanizması, uygulamanızın beklenmedik durumlarla zarifçe başa çıkmasına yardımcı olurken, kısa devre mantığı ve `throw/catch` gibi daha özel yapılar, performans optimizasyonu ve karmaşık akış kontrolü için güçlü araçlar sunar.

Bu yapıları doğru bir şekilde anlamak ve uygulamak, daha sağlam, okunabilir, verimli ve bakımı kolay Ruby kodları yazmanız için kritik öneme sahiptir. Kontrol akışı, her programın temelini oluşturur ve bu araçlara hakim olmak, Ruby programlama yolculuğunuzda size büyük avantaj sağlayacaktır. Bu konuda daha fazla bilgi ve pratik yapmak için Ruby'nin resmi dokümanlarına başvurabilirsiniz.