Ruby, Yukihiro "Matz" Matsumoto tarafından 1990'ların ortalarında geliştirilen, dinamik, açık kaynaklı, nesne yönelimli bir programlama dilidir. Geliştirici verimliliğini ve programlama keyfini artırmaya odaklanmıştır. Ruby'nin sade ve anlaşılır sözdizimi, hem yeni başlayanlar hem de deneyimli geliştiriciler için onu cazip kılar. Genellikle "programcının en iyi arkadaşı" olarak anılır, çünkü çoğu zaman aynı işi daha az kodla yapmanızı sağlar.

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

• Tek satırlık yorumlar: `#` karakteri ile başlar.
• Çok satırlık yorumlar: `=begin` ile başlar ve `=end` ile biter. Bu, nadiren kullanılan bir yöntemdir.

# Bu tek satırlık bir yorumdur.
puts "Merhaba Dünya!" # Bu da bir yorumdur.

=begin
Bu,
çok
satırlık
bir yorum bloğudur.
=end

• Yerel Değişkenler: Küçük harf veya alt çizgi ile başlar. Sadece tanımlandıkları kapsamda (metot, blok vb.) geçerlidir.
  
  Kod:

  yerel_degisken = 10
  ad = "Alice"

• Örnek Değişkenleri: `@` ile başlar. Bir nesnenin belirli bir örneğine aittir ve o nesne içindeki metotlar arasında paylaşılır.
  
  Kod:

  class Kisi
    def initialize(ad)
      @ad = ad # Örnek değişkeni
    end
  end

• Sınıf Değişkenleri: `@@` ile başlar. Bir sınıfın tüm örnekleri arasında paylaşılır ve sınıfın kendisine aittir.
  
  Kod:

  class Sayac
    @@toplam_sayac = 0 # Sınıf değişkeni
    def initialize
      @@toplam_sayac += 1
    end
  end

• Global Değişkenler: `$` ile başlar. Programın herhangi bir yerinden erişilebilir. Kullanımı genellikle önerilmez, çünkü kodun okunabilirliğini ve bakımını zorlaştırabilir.
  
  Kod:

  $global_mesaj = "Bu bir global mesajdır."

• Sabitler: Büyük harfle başlar ve genellikle tamamı büyük harftir. Değeri değiştirilmemesi beklenen değişkenlerdir, ancak Ruby'de kesinlikle sabit değildirler ve bir uyarı ile değiştirilebilirler.
  
  Kod:

  PI = 3.14159
  MAX_DEGER = 100

• Sayılar: `Integer` (tam sayılar) ve `Float` (ondalıklı sayılar).
  
  Kod:

  yas = 30           # Integer
  boy = 1.75         # Float

• Dizgiler (Strings): Tek tırnak (`'`) veya çift tırnak (`"`) arasına yazılır. Çift tırnak, string enterpolasyonuna ve kaçış karakterlerine izin verir.
  
  Kod:

  mesaj1 = 'Merhaba Dünya!'
  mesaj2 = "Adım #{ad}." # String enterpolasyonu

• Diziler (Arrays): Köşeli parantez (`[]`) ile oluşturulur. Sıralı eleman koleksiyonudur.
  
  Kod:

  sayilar = [1, 2, 3, 4, 5]
  meyveler = ["elma", "armut", "kiraz"]

• Hashler (Hashes): Süslü parantez (`{}`) ile oluşturulur. Anahtar-değer çiftlerinden oluşan bir koleksiyondur.
  
  Kod:

  kisi = { "ad" => "Ali", "yas" => 25, "sehir" => "Ankara" }
  # Sembol anahtarları ile modern hash sözdizimi
  urun = { ad: "Klavye", fiyat: 150.0 }

• Booleanlar: `true` ve `false`.
  
  Kod:

  aktif = true
  dolu = false

• Nil: Değerin yokluğunu temsil eder. Diğer dillerdeki `null` veya `None` gibidir.
  
  Kod:

  degisken_yok = nil

• Semboller (Symbols): Colon (`:`) ile başlar. Değişmez ve benzersiz tanımlayıcılardır. Özellikle hash anahtarları olarak veya metot isimleri için kullanılırlar. Bellek verimliliği sağlarlar.
  
  Kod:

  status = :pending
  renk = :mavi

• Aritmetik Operatörler: `+`, `-`, `*`, `/`, `%` (modül), `**` (üs alma).
  
  Kod:

  sonuc = 10 + 5    # 15
  fark = 20 - 7     # 13
  carpim = 4 * 6    # 24
  bolum = 10 / 3    # 3 (integer division)
  kalan = 10 % 3    # 1
  us = 2 ** 3       # 8

• Karşılaştırma Operatörleri: `==` (eşit mi), `!=` (eşit değil mi), `>` (büyük), `<` (küçük), `>=` (büyük eşit), `<=` (küçük eşit), `eql?` (değer ve tip eşitliği), `equal?` (aynı nesne mi).
  
  Kod:

  p (5 == 5)    # true
  p (10 != 7)   # true
  p (12 > 5)    # true
  p (3 < 8)     # true
  p (6 >= 6)    # true
  p (4 <= 4)    # true
  
  a = "hello"
  b = "hello"
  p (a.eql?(b))    # true (değerleri ve tipleri aynı)
  p (a.equal?(b))  # false (aynı nesne değiller)

• Mantıksal Operatörler: `&&` (VE), `||` (VEYA), `!` (DEĞİL). Kelime karşılıkları da kullanılabilir: `and`, `or`, `not`.
  
  Kod:

  x = true
  y = false
  p (x && y)    # false
  p (x || y)    # true
  p (!x)        # false

• Atama Operatörleri: `=` (atama), `+=`, `-=`, `*=`, `/=`, `%=`, `**=`.
  
  Kod:

  sayi = 10
  sayi += 5   # sayi = sayi + 5, yani 15
  sayi *= 2   # sayi = sayi * 2, yani 30

• Range Operatörleri: `..` (dahil) ve `...` (hariç).
  
  Kod:

  aralik1 = 1..5   # 1, 2, 3, 4, 5
  aralik2 = 1...5  # 1, 2, 3, 4

• If/Elsif/Else/Unless: Koşullu ifadeler. `unless` `if not` gibidir.
  
  Kod:

  yas = 18
  if yas >= 18
    puts "Oy kullanabilirsiniz."
  elsif yas >= 16
    puts "Sadece belirli durumlarda oy kullanabilirsiniz."
  else
    puts "Oy kullanamazsınız."
  end
  
  # Unless kullanımı
  aktif = false
  unless aktif
    puts "Kullanıcı pasif durumda."
  end

• Case/When: Birden çok koşulu daha düzenli bir şekilde kontrol etmek için kullanılır.
  
  Kod:

  gun = "Pazartesi"
  case gun
  when "Pazartesi"
    puts "Haftanın ilk günü."
  when "Cuma"
    puts "Hafta sonuna az kaldı!"
  else
    puts "Normal bir gün."
  end

• Döngüler:
  • While Döngüsü: Belirtilen koşul doğru olduğu sürece çalışır.
    
    Kod:

        i = 0
        while i < 5
          puts "Sayı: #{i}"
          i += 1
        end

  • Until Döngüsü: Belirtilen koşul yanlış olduğu sürece çalışır. `while not` gibidir.
    
    Kod:

        i = 0
        until i >= 5
          puts "Sayı (until): #{i}"
          i += 1
        end

  • For Döngüsü: Belirli bir aralık veya koleksiyon üzerinde döner.
    
    Kod:

        for sayi in 1..3
          puts "For döngüsü: #{sayi}"
        end

  • Each Metodu: Ruby'nin koleksiyonlar üzerinde döngü yapmanın en yaygın yoludur.
    
    Kod:

        meyveler = ["elma", "armut", "kiraz"]
        meyveler.each do |meyve|
          puts "En sevdiğim meyve: #{meyve}"
        end

  • Loop Metodu: Koşulsuz bir döngü oluşturur, genellikle `break` ile sonlandırılır.
    
    Kod:

        sayac = 0
        loop do
          puts "Loop sayacı: #{sayac}"
          sayac += 1
          break if sayac > 3
        end

  • Döngü Kontrolü:
    • `break`: Döngüyü tamamen sonlandırır.
    • `next`: Döngünün mevcut iterasyonunu atlar ve bir sonraki iterasyona geçer.
    • `redo`: Mevcut iterasyonu yeniden başlatır.
    Kod:

        (1..5).each do |num|
          next if num == 3 # 3'ü atlar
          puts "Num: #{num}"
          break if num == 4 # 4'te döngüyü sonlandırır
        end

def selamlama(ad, soyad = "Bilinmiyor") # Varsayılan parametre
  "Merhaba, #{ad} #{soyad}!"
end

puts selamlama("Ayşe")
puts selamlama("Can", "Yılmaz")

def toplam(*sayilar) # Değişken sayıda parametre
  sayilar.sum
end

puts toplam(1, 2, 3)
puts toplam(5, 10, 15, 20)

# Dönüş değeri: Ruby'de bir metodun son ifadesi otomatik olarak geri döner.
def carpma(a, b)
  a * b
end

sonuc = carpma(7, 8)
puts "Çarpım: #{sonuc}"

• Sınıf Tanımı: `class` anahtar kelimesi ile bir şablon tanımlanır.
• `initialize` Metodu: Bir sınıfın yeni bir örneği (`nesnesi`) oluşturulduğunda otomatik olarak çağrılan özel bir metottur (kurucu metot/constructor).
  
  Kod:

  class Urun
    # initialize metodu, yeni bir Urun nesnesi oluşturulduğunda çağrılır
    def initialize(ad, fiyat)
      @ad = ad     # Örnek değişkeni
      @fiyat = fiyat # Örnek değişkeni
    end
  
    def bilgileri_goster
      "Ürün: #{@ad}, Fiyat: #{@fiyat} TL"
    end
  end
  
  # Nesne oluşturma
  kalem = Urun.new("Kurşun Kalem", 5.0)
  defter = Urun.new("Defter", 12.50)
  
  puts kalem.bilgileri_goster
  puts defter.bilgileri_goster

• Erişim Belirleyiciler: Metotların ve değişkenlerin dışarıdan erişilebilirliğini kontrol eder.
  • `public`: Varsayılandır. Her yerden erişilebilir.
  • `private`: Sadece tanımlandığı sınıf içinden çağrılabilir. Alıcı nesne belirtilemez (implicit self).
  • `protected`: Tanımlandığı sınıf veya alt sınıflarının nesneleri üzerinden erişilebilir.
  Kod:

  class Hesap
    def initialize(bakiye)
      @bakiye = bakiye
    end
  
    def bakiye_sorgula # Public method
      @bakiye
    end
  
    private # Altındaki metotlar private olur
  
    def gizli_islem
      puts "Gizli bir işlem yapılıyor..."
      @bakiye * 0.01
    end
  
    public # Tekrar public metot tanımlamak için
  
    def bakiye_artir(miktar)
      @bakiye += miktar
      gizli_islem # Sınıf içinden private metodun çağrılması
    end
  end
  
  hesap = Hesap.new(1000)
  puts "Başlangıç bakiyesi: #{hesap.bakiye_sorgula}"
  hesap.bakiye_artir(500)
  puts "Yeni bakiye: #{hesap.bakiye_sorgula}"
  # hesap.gizli_islem # Hata verir: private method `gizli_islem' called for #<Hesap:...>

• `attr_reader`, `attr_writer`, `attr_accessor`: Nesne özelliklerine (`instance variables`) erişimi kolaylaştıran yardımcı metotlar.
  • `attr_reader :degisken`: Sadece okuma (getter) metodu oluşturur.
  • `attr_writer :degisken`: Sadece yazma (setter) metodu oluşturur.
  • `attr_accessor :degisken`: Hem okuma hem de yazma metodu oluşturur.
  Kod:

  class Calisan
    attr_accessor :ad, :soyad # Hem okuma hem yazma
    attr_reader :maas # Sadece okuma
  
    def initialize(ad, soyad, maas)
      @ad = ad
      @soyad = soyad
      @maas = maas
    end
  end
  
  c = Calisan.new("Deniz", "Akın", 7500)
  puts c.ad       # Okuma
  c.ad = "Derya"  # Yazma
  puts c.ad
  # c.maas = 8000 # Hata verir, çünkü sadece reader tanımlı
  puts c.maas

• Bloklar: Metot çağrısına argüman olarak geçirilebilen adsız kod parçalarıdır. `do...end` veya `{...}` ile tanımlanır.
  
  Kod:

  # Her sayıyı iki katına çıkarma
  [1, 2, 3].map do |n|
    n * 2
  end
  # => [2, 4, 6]
  
  # Bir metoda blok geçirme ve yield kullanma
  def selam_ver
    yield if block_given? # Eğer blok verilmişse çalıştır
    puts "Güle güle!"
  end
  
  selam_ver { puts "Merhaba!" }
  selam_ver

• Proc: Bir bloğu bir nesneye dönüştürmenin bir yoludur. Bir değişkende saklanabilir ve daha sonra çağrılabilir.
  
  Kod:

  my_proc = Proc.new { |isim| puts "Merhaba, #{isim}!" }
  my_proc.call("Dünya")

• Lambda: Proc'a benzer, ancak parametre sayısını ve `return` davranışını daha katı bir şekilde uygular.
  
  Kod:

  my_lambda = lambda { |isim| puts "Merhaba, #{isim}!" }
  my_lambda.call("Evren")
  
  # Proc ve Lambda farkı
  # Proc, parametre sayısına dikkat etmez ve metodun dışına çıkar.
  # Lambda, parametre sayısına dikkat eder ve sadece kendi bloğundan döner.
  def proc_test
    my_proc = Proc.new { return "Proc'tan dönüş!" }
    my_proc.call
    "Proc metot içinden dönüldü." # Bu satıra asla ulaşılamaz
  end
  
  def lambda_test
    my_lambda = -> { return "Lambda'dan dönüş!" }
    my_lambda.call
    "Lambda metot içinden dönüldü." # Bu satıra ulaşılır
  end
  
  puts proc_test
  puts lambda_test

module Hesaplamalar
  PI = 3.14159

  def alan_hesapla(yaricap)
    PI * yaricap * yaricap
  end

  def cevre_hesapla(yaricap)
    2 * PI * yaricap
  end
end

class Daire
  include Hesaplamalar # Modülü dahil et

  def initialize(yaricap)
    @yaricap = yaricap
  end

  def goster_bilgi
    # Modüldeki metotları doğrudan kullanabiliriz
    puts "Yarıçap: #{@yaricap}"
    puts "Alan: #{alan_hesapla(@yaricap).round(2)}"
    puts "Çevre: #{cevre_hesapla(@yaricap).round(2)}"
  end
end

daire = Daire.new(5)
daire.goster_bilgi

# extend kullanımı: Sınıf metodu olarak dahil etme
module Loggable
  def log(message)
    puts "[LOG] #{Time.now}: #{message}"
  end
end

class VeritabaniBaglantisi
  extend Loggable # Sınıf metodu olarak dahil et
  
  def self.baglan
    log("Veritabanına bağlanılıyor...") # class method'dan çağrılır
    # Bağlantı kodları
    log("Bağlantı başarılı.")
  end
end

VeritabaniBaglantisi.baglan

• `begin...rescue`: Potansiyel hatalı kodu `begin` bloğuna koyar, hata oluşursa `rescue` bloğu çalışır.
  
  Kod:

  begin
    # Hata olasılığı olan kod
    sonuc = 10 / 0 # ZeroDivisionError oluşur
  rescue ZeroDivisionError => e
    puts "Hata oluştu: Sıfıra bölme hatası! #{e.message}"
  rescue => e # Genel hata yakalama
    puts "Beklenmedik bir hata: #{e.class} - #{e.message}"
  ensure # Hata olsun veya olmasın her zaman çalışır
    puts "İşlem tamamlandı veya başarısız oldu."
  end
  
  puts "\n*** Başarılı durum ***"
  begin
    dosya = File.open("gecerli_dosya.txt", "w")
    dosya.puts "Merhaba Ruby!"
    dosya.close
  rescue Errno::ENOENT => e
    puts "Dosya bulunamadı hatası: #{e.message}"
  else # Hata oluşmazsa çalışır
    puts "Dosya başarıyla yazıldı."
  ensure
    puts "Dosya işlemi bitirildi."
  end

• `retry`: `rescue` bloğundan sonra `begin` bloğunu yeniden çalıştırmak için kullanılır. Dikkatli kullanılmalıdır, sonsuz döngüye yol açabilir.
  
  Kod:

  def oku_sayi
    begin
      puts "Lütfen bir sayı girin:"
      sayi = gets.chomp.to_i
      raise ArgumentError, "Sıfır girilemez!" if sayi == 0
      puts "Girilen sayı: #{sayi}"
    rescue ArgumentError => e
      puts "Hata: #{e.message}. Lütfen tekrar deneyin."
      retry # begin bloğunu yeniden başlat
    rescue
      puts "Geçersiz giriş. Lütfen sayı girin."
      retry
    end
  end
  
  # oku_sayi