Giriş: Ruby'de Değişkenlerin Önemi ve Temel Yapısı
Programlamanın temel taşlarından biri olan değişkenler, veri depolamanın ve yönetmenin ayrılmaz bir parçasıdır. Ruby gibi dinamik, nesne yönelimli bir dilde değişkenler, programcının karmaşık mantık yürütmesini ve verileri efektif bir şekilde işlemesini sağlar. Ruby, değişkenlerin türünü çalışma zamanında otomatik olarak belirleyen esnek bir yapıya sahiptir, bu da kod yazımını hızlandırır ve basitleştirir. Ancak bu esneklik, değişkenlerin kapsamını ve yaşam döngüsünü doğru anlamayı daha da kritik hale getirir. Bu kapsamlı rehberde, Ruby'deki farklı değişken türlerini, bunların kapsam kurallarını, kullanım alanlarını ve bunlarla ilgili en iyi uygulamaları derinlemesine inceleyeceğiz. Her bir değişken türü için açıklayıcı kod örnekleri sunarak konuyu somutlaştıracak ve yaygın hatalardan kaçınmak için ipuçları vereceğiz. Amacımız, Ruby'de değişken yönetiminde ustalaşmanıza yardımcı olmaktır. Değişkenler sadece sayıları veya metinleri tutan kutular değildir; aynı zamanda programınızın dinamik davranışını ve veri akışını belirleyen yapısal unsurlardır. Doğru değişken türünü doğru yerde kullanmak, okunabilir, sürdürülebilir ve hatasız kod yazmanın anahtarıdır.

Ruby'deki Değişken Türleri ve Kapsamları
Ruby'de beş ana değişken türü bulunmaktadır. Her birinin kendine özgü bir başlangıç karakteri ve buna bağlı olarak farklı bir kapsamı ve kullanım amacı vardır:

• Yerel Değişkenler (Local Variables)
  * Küçük bir harf veya alt çizgi ile başlarlar (örneğin, `sayi`, `ad_soyad`).
  * Tanımlandıkları belirli bir kod bloğu (metot, döngü, sınıf tanımı vb.) içinde geçerlidirler. Bu bloğun dışından erişilemezler, bu da onları geçici veriler için ideal kılar.
  * Çok sık kullanılırlar ve genellikle programın içindeki geçici hesaplamalar veya dönüşümler için tercih edilirler.
  *
  Kod:

        def hesapla
          x = 10 # Yerel değişken
          y = 20 # Yerel değişken
          toplam = x + y
          puts "Toplam: #{toplam}"
        end
  
        hesapla # Çıktı: Toplam: 30
        # puts x # Hata verir: Tanımlı değil (yerel kapsamın dışında)

  * Kapsam: Sadece tanımlandıkları metodun veya bloğun içinde geçerlidirler. Blok bittiğinde bellekten atılırlar.
  
• Örnek Değişkenleri (Instance Variables)
  * `@` sembolü ile başlarlar (örneğin, `@isim`, `@yas`).
  * Bir sınıfın belirli bir nesnesine (örneğine) aittirler. Bir nesnenin farklı metotları arasında veri paylaşmak için kullanılırlar.
  * Her objenin kendi örnek değişkenlerinin bir kopyası vardır; yani bir objenin `@isim` değeri diğer bir objenin `@isim` değerinden bağımsızdır.
  *
  Kod:

        class Kullanici
          def initialize(ad, email)
            @ad = ad       # Örnek değişkeni
            @email = email # Örnek değişkeni
          end
  
          def tanit
            puts "Ad: #{@ad}, E-posta: #{@email}"
          end
  
          def guncelle_email(yeni_email)
            @email = yeni_email
            puts "E-posta güncellendi: #{@email}"
          end
        end
  
        kullanici1 = Kullanici.new("Elif", "elif@example.com")
        kullanici2 = Kullanici.new("Mert", "mert@example.com")
  
        kullanici1.tanit # Çıktı: Ad: Elif, E-posta: elif@example.com
        kullanici2.tanit # Çıktı: Ad: Mert, E-posta: mert@example.com
  
        kullanici1.guncelle_email("elif.yeni@example.com")
        kullanici1.tanit # Çıktı: Ad: Elif, E-posta: elif.yeni@example.com
        kullanici2.tanit # Çıktı: Ad: Mert, E-posta: mert@example.com (kullanici2 etkilenmedi)

  * Kapsam: Bir sınıfın belirli bir örneği içinde geçerlidirler. Nesne bellekten atıldığında örnek değişkenleri de yok olur.
  
• Sınıf Değişkenleri (Class Variables)
  * `@@` sembolü ile başlarlar (örneğin, `@@sayac`, `@@toplam_nesne_sayisi`).
  * Bir sınıfın tüm örnekleri tarafından ve sınıfın kendisi tarafından paylaşılan veriyi tutarlar. Yani, tüm objeler aynı `@@degisken` değerini görür ve değiştirirse diğerleri de bu değişikliği fark eder.
  * Genellikle bir sınıfın tüm örnekleri için geçerli olan ortak bilgileri veya istatistikleri depolamak için kullanılırlar.
  *
  Kod:

        class Urun
          @@toplam_urun_sayisi = 0 # Sınıf değişkeni
  
          def initialize(ad, fiyat)
            @ad = ad
            @fiyat = fiyat
            @@toplam_urun_sayisi += 1 # Her yeni ürün eklendiğinde sayacı artır
          end
  
          def self.get_toplam_urun_sayisi
            @@toplam_urun_sayisi
          end
        end
  
        urun1 = Urun.new("Laptop", 1200)
        urun2 = Urun.new("Klavye", 75)
        urun3 = Urun.new("Fare", 30)
  
        puts "Toplam ürün sayısı: #{Urun.get_toplam_urun_sayisi}" # Çıktı: Toplam ürün sayısı: 3
  
        class ElektronikUrun < Urun
          # ElektronikUrun sınıfı da @@toplam_urun_sayisi'nı paylaşır
        end
  
        e_urun1 = ElektronikUrun.new("Kulaklık", 150)
        puts "Güncel toplam ürün sayısı: #{Urun.get_toplam_urun_sayisi}" # Çıktı: Güncel toplam ürün sayısı: 4

  * Kapsam: Sınıfın kendisi ve o sınıftan türetilmiş tüm alt sınıflar ile bu sınıfların tüm örnekleri arasında paylaşılır.
  
• Global Değişkenler (Global Variables)
  * `$` sembolü ile başlarlar (örneğin, `$debug_modu`, `$uygulama_versiyonu`).
  * Bir Ruby uygulamasının herhangi bir yerinden erişilebilirler. En geniş kapsama sahip değişkendir.
  * Kötüye kullanımı, kodun karmaşıklığını artırabilir ve beklenmedik yan etkilere yol açabilir. Genellikle kaçınılması önerilir çünkü kodun modülerliğini bozar ve bağımlılıkları artırır.
  *
  Kod:

        $veri_tabani_baglantisi = nil
  
        def baglanti_kur
          unless $veri_tabani_baglantisi
            $veri_tabani_baglantisi = "Bağlantı Kuruldu: DB Sunucusu"
            puts $veri_tabani_baglantisi
          else
            puts "Veritabanı bağlantısı zaten mevcut."
          end
        end
  
        def veri_getir
          if $veri_tabani_baglantisi
            puts "Veri getiriliyor... #{$veri_tabani_baglantisi}"
          else
            puts "Önce veritabanı bağlantısı kurulmalı!"
          end
        end
  
        baglanti_kur # Çıktı: Bağlantı Kuruldu: DB Sunucusu
        veri_getir   # Çıktı: Veri getiriliyor... Bağlantı Kuruldu: DB Sunucusu
        baglanti_kur # Çıktı: Veritabanı bağlantısı zaten mevcut.

  * Kapsam: Tüm Ruby uygulaması boyunca erişilebilirler. Uygulama çalıştığı sürece varlıklarını korurlar.
  *

  Ruby topluluğunda global değişkenlerin kullanımı genellikle kötü bir uygulama olarak kabul edilir. Büyük ve karmaşık projelerde kodun izlenebilirliğini ve test edilebilirliğini ciddi şekilde azaltabilirler. Alternatif olarak, bağımlılık enjeksiyonu veya yapılandırma nesneleri gibi daha güvenli yaklaşımlar tercih edilmelidir.

  Genişletmek için tıkla ...

• Sabitler (Constants)
  * Büyük bir harfle başlarlar ve genellikle tamamen büyük harf ve alt çizgilerle yazılırlar (örneğin, `PI`, `MAX_USERS`, `APP_VERSION`).
  * Adından da anlaşılacağı gibi, değişmemesi beklenen değerleri temsil ederler. Ancak Ruby'de, diğer bazı dillerin aksine, sabitler aslında tamamen 'sabit' değildir; bir sabitin değeri değiştirilmeye çalışıldığında sadece bir uyarı (warning) verirler, ancak değer değiştirilir.
  * Sınıflar ve modüller de birer sabit olarak kabul edilir ve bu nedenle büyük harfle başlarlar.
  *
  Kod:

        PI = 3.14159
        SABIT_MESAJ = "Bu bir sabittir."
  
        class Ayarlar
          SITE_ADI = "Benim Web Sitem"
          ADMIN_EMAIL = "admin@example.com"
        end
  
        puts PI           # Çıktı: 3.14159
        puts SABIT_MESAJ  # Çıktı: Bu bir sabittir.
        puts Ayarlar::SITE_ADI # Sınıf kapsamındaki sabite erişim: Benim Web Sitem
  
        # PI = 3.0 # Ruby uyarı verir ancak değeri değiştirir
        # puts PI # Çıktı: 3.0 (ve bir uyarı mesajı)

  * Kapsam: Tanımlandıkları sınıf, modül veya global kapsamda geçerlidirler. Sınıf veya modül hiyerarşisine göre miras alınabilir veya dışarıdan erişilebilirler.

Değişken Kapsamının Derinlemesine İncelenmesi ve Yaşam Döngüsü
Her değişken türünün kapsamı, o değişkenin programın hangi bölümlerinden erişilebileceğini ve ne kadar süreyle bellekte kalacağını belirler. Yerel değişkenler, tanımlandıkları blok sona erdiğinde bellekten atılırlar. Bu, bellek yönetimini optimize eder ve yan etkileri azaltır. Örnek değişkenleri, ilgili nesne bellekte kaldığı sürece yaşar; nesneye atıf kalmadığında ve çöp toplayıcı tarafından temizlendiğinde onlar da yok olur. Sınıf değişkenleri, sınıf tanımı yüklendiği andan itibaren uygulama kapanana kadar varlıklarını sürdürürler. Global değişkenler ise uygulamanın başlangıcından sonuna kadar her zaman erişilebilirdir, bu da onları potansiyel olarak tehlikeli hale getirir çünkü herhangi bir kod parçası tarafından istenmeyen şekilde değiştirilebilirler. Sabitler de sınıf değişkenleri gibi uygulama ömrü boyunca var olurlar, ancak değerlerinin değiştirilmesi önerilmez ve bir uyarıya yol açar.

En İyi Uygulamalar ve Yaygın Hatalar
Ruby'de değişkenleri verimli ve güvenli bir şekilde kullanmak için bazı en iyi uygulamalar ve kaçınılması gereken yaygın hatalar vardır:

• Global Değişkenlerden Kaçınma: Mümkün olduğunca global değişken kullanımından uzak durun. Kodunuzun test edilebilirliğini, okunabilirliğini ve bakımını zorlaştırırlar. Genellikle daha iyi alternatifler (metot parametreleri, sınıf/örnek değişkenleri, yapılandırma objeleri) mevcuttur.
• Anlamlı İsimlendirme: Değişken isimleri, ne tuttuklarını ve ne işe yaradıklarını açıkça belirtmelidir. Örneğin, `x` yerine `kullanici_sayisi` kullanmak kodu çok daha anlaşılır yapar.
• Doğru Kapsamda Kullanım: Her zaman en dar kapsamlı değişkeni tercih edin. Eğer bir değişken sadece bir metot içinde gerekiyorsa, onu yerel değişken olarak tanımlayın. Tüm nesne için geçerliyse örnek değişkeni, tüm sınıf için geçerliyse sınıf değişkeni kullanın.
• Sabitlere Saygı Duyma: Sabitler teknik olarak değiştirilebilir olsa da, onlara sabitlermiş gibi davranın. Değerlerini değiştirmekten kaçının; bu, programınızda mantık hatalarına ve beklenmedik davranışlara yol açabilir.
• Bellek Yönetimi Bilinci: Büyük veri yapılarını veya uzun ömürlü nesneleri tutan değişkenler konusunda dikkatli olun. Kapsam dışına çıktıklarında bellekten temizlenmeleri Ruby'nin çöp toplayıcısı tarafından yönetilir, ancak aşırı kullanım veya referans döngüleri bellek sızıntılarına neden olabilir.
• Kaynakları İnceleme: Ruby'nin değişkenleri ve genel syntax'ı hakkında daha fazla bilgi edinmek için Ruby Resmi Dokümantasyonu: Değişkenler sayfasını ve RubyGuides: Ruby Variables gibi güvenilir blog yazılarını düzenli olarak kontrol edin.

Sonuç
Ruby'de değişkenler, programlamanın temel yapı taşlarıdır ve dilin dinamik ve esnek yapısını yansıtırlar. Yerel, örnek, sınıf, global değişkenler ve sabitler, her birinin kendine özgü bir kapsamı ve kullanım alanı ile gelir. Bu farklılıkları anlamak ve her durumda doğru değişken türünü seçmek, temiz, okunabilir, bakımı kolay ve performanslı Ruby kodları yazmanın anahtarıdır. Özellikle global değişkenlerden kaçınma ve anlamlı isimlendirme gibi en iyi uygulamalara bağlı kalmak, yazılım geliştirme sürecinizi büyük ölçüde iyileştirecektir. Ruby'nin değişken mekanizmalarını ustaca kullanmak, dilin gücünü tam anlamıyla ortaya çıkarmanıza ve daha sağlam uygulamalar geliştirmenize olanak tanır. Unutmayın, iyi bir değişken yönetimi, iyi bir yazılım mimarisinin temelini oluşturur.