Ruby Veri Tipleri ve Literaller: Sayıdan Heredoc Yazımına

Literaller ve sınıfları

nil, true ve false

nil genellikle "değer yok" veya "bilinmiyor" anlamında kullanılır. Koşul ifadelerinde yalnızca nil ve false yanlış sayılır; 0, boş metin ve boş dizi dahil diğer her şey doğrudur. Bu kuralın koşullardaki etkisini Ruby if, unless ve case yazısında ayrıntılı ele alıyoruz.

p nil.class     # çıktı: NilClass
p true.class    # çıktı: TrueClass
p false.class   # çıktı: FalseClass
p nil.to_a      # çıktı: []
p nil.to_s      # çıktı: ""

Sayı literalleri

Tam sayılar istenen büyüklükte yazılabilir; okunabilirlik için rakamların arasına alt çizgi koyabilirsiniz. 0x on altılık, 0b ikilik, 0o veya yalnızca baştaki 0 sekizlik tabanı belirtir. Kayan noktalı sayılarda e ile üs yazılır. Sonuna r eklenen sayı Rational, i eklenen sayı Complex olur. Rational literalleri otomatik olarak sadeleştirilir.

p 1_000_000        # çıktı: 1000000
p 0xff             # çıktı: 255
p 0b1010           # çıktı: 10
p 0o17             # çıktı: 15
p 017              # çıktı: 15
p 12.5e-1          # çıktı: 1.25
p 2/4r             # çıktı: (1/2)
p 1.2r             # çıktı: (6/5)
p 2i * 2i          # çıktı: (-4+0i)
p((2**100).class)  # çıktı: Integer
p 7 / 2            # çıktı: 3
p 7 / 2.0          # çıktı: 3.5

Metin literalleri

Çift tırnaklı metinler #{...} ile değer yerleştirmeye (interpolation) ve \n, \t, \u00e7 gibi kaçış dizilerine izin verir. Tek tırnaklı metinler ise ikisini de kapatır; yalnızca \' ve \\ özel anlam taşır. Yan yana yazılan metin literalleri otomatik birleştirilir. Soru işaretinden sonra gelen tek karakter (?A) tek harflik bir metin üretir. %q() tek tırnak gibi, %Q() ve kısaca %() çift tırnak gibi davranır; metnin içinde tırnak işareti çoksa işinizi kolaylaştırır.

ad = "Ayşe"
p "Merhaba #{ad}\tnasılsın?"     # çıktı: "Merhaba Ayşe\tnasılsın?"
p 'Merhaba #{ad}\t'              # çıktı: "Merhaba \#{ad}\\t"
puts "satır1\nsatır2"
# Çıktı:
# satır1
# satır2
p "bir" "iki"                    # çıktı: "biriki"
p ?A                             # çıktı: "A"
p "ç"                       # çıktı: "ç"
p %q(Tek tırnak gibi: #{ad})     # çıktı: "Tek tırnak gibi: \#{ad}"
p %Q(Çift tırnak gibi: #{ad})    # çıktı: "Çift tırnak gibi: Ayşe"

İkinci satırın çıktısında \#{ad} görünmesinin nedeni, p metodunun değeri inspect biçiminde yazmasıdır: metin gerçekten #{ad} karakterlerini içerir, inspect bunun yerleştirme olmadığını göstermek için önüne ters bölü koyar. Metin metotlarının tamamı için Ruby String metotları yazısına bakın.

Heredoc: çok satırlı metin

Uzun ve çok satırlı metinler için heredoc kullanılır. <<AD ile açılır ve yalnızca AD yazan satırla kapanır; sonuç son satır sonunu da içerir. <<- biçimi kapanış satırının girintili yazılmasına izin verir. <<~ (squiggly heredoc) ise en az girintili satırın girintisini bütün satırlardan siler; kod içinde düzgün girintili metin yazmanın en rahat yoludur. Açılış adı tek tırnak içine alınırsa yerleştirme ve kaçış dizileri kapanır. Açılış satırında heredoc'a doğrudan metot da çağrılabilir.

dil = "Ruby"
metin = <<~METIN
  Merhaba,
    #{dil} ile heredoc yazıyoruz.
  Son satır.
METIN
puts metin
# Çıktı:
# Merhaba,
#   Ruby ile heredoc yazıyoruz.
# Son satır.

ham = <<~'HAM'
  Burada #{dil} yerine konmaz.
HAM
p ham                  # çıktı: "Burada \#{dil} yerine konmaz.\n"

p <<~TEK.chomp         # çıktı: "satır sonu silindi"
  satır sonu silindi
TEK

Sembol literalleri

Sembol, yorumlayıcı içinde bir adı temsil eder ve iki noktayla yazılır: :durum. Boşluk veya özel karakter içeren semboller tırnakla yazılır. Aynı adı taşıyan semboller her zaman aynı nesnedir; aynı içerikli iki metin literali ise iki ayrı nesne üretir. Bu fark, sembollerin neden hash anahtarı olarak sık kullanıldığını açıklar; ayrıntılar Ruby Symbol ve String farkı yazısında.

p :durum                    # çıktı: :durum
p :"çok kelimeli ad"        # çıktı: :"çok kelimeli ad"
p %s(sembol)                # çıktı: :sembol
p :durum.equal?(:durum)     # çıktı: true
p "durum".equal?("durum")   # çıktı: false

Dizi literalleri ve %w, %i

Diziler köşeli parantez içinde virgülle ayrılmış ifadelerle yazılır ve farklı türde elemanlar içerebilir. Yalnızca kelimelerden oluşan diziler için %w (metin dizisi) ve %i (sembol dizisi) çok daha kısadır. Büyük harfli sürümleri %W ve %I yerleştirmeye izin verir. Kelimenin içinde boşluk gerekiyorsa ters bölüyle kaçırılır.

p [1, "iki", :uc, [4, 5]]     # çıktı: [1, "iki", :uc, [4, 5]]
p %w[elma armut kiraz]       # çıktı: ["elma", "armut", "kiraz"]
n = 3
p %W[kutu#{n} kutu#{n + 1}]  # çıktı: ["kutu3", "kutu4"]
p %i[ad soyad yas]           # çıktı: [:ad, :soyad, :yas]
p %w[New\ York Ankara]       # çıktı: ["New York", "Ankara"]
p %w[a, b]                   # çıktı: ["a,", "b"]

Son satır sık yapılan bir hatayı gösteriyor: %w içinde virgül ayırıcı değildir, kelimenin parçası olur. Dizi metotları için Ruby Array metotları yazısına bakın.

Hash literalleri

Hash, süslü parantez içinde anahtar-değer çiftleriyle yazılır. Anahtar herhangi bir nesne olabilir ve => ile değere bağlanır. Anahtarlar sembolse kısa ad: değer yazımı kullanılır; aynı yazım metotların anahtar kelime argümanlarında da geçerlidir. Değer, anahtarla aynı adı taşıyan bir değişkenden alınacaksa değer kısmı atlanabilir: { x:, y: }.

kisi = { ad: "Can", yas: 30 }
p kisi                     # çıktı: {ad: "Can", yas: 30}
p kisi[:ad]                # çıktı: "Can"

eski = { "ad" => "Can", 1 => "bir" }
p eski                     # çıktı: {"ad" => "Can", 1 => "bir"}
p({ "kod no": 7 })         # çıktı: {"kod no": 7}

x = 10
y = 20
p({ x:, y: })              # çıktı: {x: 10, y: 20}

Bir metoda hash literali verirken parantez kullanmayı unutmayın: p { a: 1 } yazımında süslü parantez hash olarak değil, p metoduna verilen bir blok olarak ayrıştırılır ve Ruby 4.0 bu satırda SyntaxError verir. Doğrusu p({ a: 1 }) veya p(a: 1) yazmaktır.

Aralık (Range) literalleri

İki nokta (..) bitiş değerini dahil eder, üç nokta (...) hariç tutar. Başlangıcı veya bitişi yazılmayan aralıklar sonsuz aralıktır. Aralıklar yalnızca sayılarla değil, sıralanabilen her nesneyle çalışır. Ayrıntılar Ruby Range aralıklar yazısında.

p((1..5).to_a)            # çıktı: [1, 2, 3, 4, 5]
p((1...5).to_a)           # çıktı: [1, 2, 3, 4]
p((1..).first(3))         # çıktı: [1, 2, 3]
p(("a".."e").to_a)        # çıktı: ["a", "b", "c", "d", "e"]
p((..10).include?(-3))    # çıktı: true

Düzenli ifade ve lambda literalleri

Düzenli ifadeler iki eğik çizgi arasında yazılır ve sonuna i (büyük/küçük harf duyarsız) gibi seçenekler eklenebilir. Desen içinde eğik çizgi çoksa %r{...} yazımı kaçış ihtiyacını ortadan kaldırır. -> ile yazılan lambda literali ise çağrılabilir bir Proc nesnesi üretir. Bu iki konu serideki Ruby Regexp ve Ruby proc ve lambda farkı yazılarında ayrıntılı işleniyor.

re = /(\d{4})-(\d{2})/
p re.class                     # çıktı: Regexp
p "Tarih: 2026-11" =~ re       # çıktı: 7
p "ANKARA" =~ /ankara/i        # çıktı: 0
yol = %r{/blog/(\w+)}
p yol.match("/blog/ruby")[1]   # çıktı: "ruby"

kare = ->(x) { x * x }
p kare.call(4)                 # çıktı: 16
p kare.(5)                     # çıktı: 25
p kare.lambda?                 # çıktı: true

Yüzde literallerinin özeti

Yüzde literallerinde ayırıcı olarak [], (), {}, <> çiftleri veya harf ve rakam olmayan herhangi bir ASCII karakter kullanılabilir. Çift ayırıcılar doğru eşleştikleri sürece içeride ters bölü olmadan iç içe yazılabilir.

Sık yapılan hatalar

• Tek tırnaklı metinde yerleştirme beklemek: 'Merhaba #{ad}' değeri yerleştirmez; çift tırnak kullanın.
• %w içinde virgül kullanmak: virgül kelimenin parçası olur.
• Metot argümanında parantezsiz hash yazmak: p { a: 1 } blok olarak ayrıştırılır.
• Tam sayı bölmesini unutmak: 7 / 2 sonucu 3'tür; ondalıklı sonuç için işlenenlerden biri Float olmalıdır.
• Eski inspect çıktılarını beklemek: Ruby 3.4'ten bu yana hash'ler {a: 1} biçiminde yazdırılır.

Sık Sorulan Sorular

Ruby'de tek tırnak mı, çift tırnak mı kullanmalıyım?

İkisi de String üretir. Değer yerleştirme veya \n gibi kaçış dizisi gerekiyorsa çift tırnak şarttır. Metnin içeriğini olduğu gibi korumak istediğinizde tek tırnak daha güvenlidir.

Hash'te sembol anahtar mı, metin anahtar mı kullanmalıyım?

Kod içinde sabit adlarla eriştiğiniz alanlar için sembol anahtarlar yaygındır ve kısa yazımı destekler. Anahtarlar dışarıdan gelen veriden oluşuyorsa (örneğin ayrıştırılan JSON) metin anahtarlar doğal olarak ortaya çıkar. İkisi farklı anahtarlardır: h[:ad] ile h["ad"] aynı değeri döndürmez. JSON ile çalışırken bu konu Ruby JSON kullanımı yazısında ele alınıyor.

Heredoc ile normal çok satırlı metin arasındaki fark nedir?

Çift tırnaklı metin de birden fazla satıra yayılabilir, ama içindeki tırnakları kaçırmanız gerekir. Heredoc tırnak kaçırma ihtiyacını ortadan kaldırır ve <<~ biçimi kod girintisini metinden ayırır; SQL sorguları, şablonlar ve uzun mesajlar için daha okunaklıdır.

Büyük sayılarda taşma olur mu?

Ruby'de tam sayılar istenen büyüklükte yazılabilir ve 2**100 gibi büyük sonuçlar da Integer olarak kalır. Kayan noktalı sayılar ise sınırlı hassasiyettedir; bu fark sayılar yazısında ayrıntılı ele alınıyor.

Marka adları sahiplerine aittir. Bu yazı bağımsız bir teknik rehberdir; adı geçen kuruluşlarla bayilik veya ortaklık ilişkisi bulunduğu anlamına gelmez.

İlgili içerikler: Ruby öğrenme rehberi · Ruby değişkenler ve sabitler · Ruby String metotları · Ruby Hash metotları · Ruby Symbol ve String farkı