20 dakikada RUBY

İnteraktif Ruby

Ruby kendisine girdiğiniz her Ruby satırının sonucunu gösteren bir programla beraber gelir. Ruby ile etkileşimli bir oturumda oynamak bu dili öğrenmek için dehşet verici bir yoldur.

IRB’i açın (Interactive Ruby anlamına gelir).

• Eğer Mac OS X kullanıyorsanız Terminal açın ve yazın : irb, sonra enter basın.
• Eğer Linux kullanıyorsanız konsol açın ve yazın : irb, sonra enter basın.
• Eğer Windows kullanıyorsanız başlat menüsü Ruby bölümündenInteractive Ruby çalıştırın.

irb(main):001:0>

Tamam açıldı şimdi ne yapacağız?

Şunu yazın : "Hello World"

irb(main):001:0> "Hello World"
=> "Hello World"

Ruby Size İtaat Eder!

Ne yaptık şimdi? Dünyanın en kısa “Hello World” programını mı yazdık? Tam olarak değil. İkinci satır sadece IRB’in yaptığı işlemin sonucunu bildirme tekniği. Eğer ekrana “Hello World” yazdırmak istiyorsak daha fazla birşeyler yapmalıyız:

irb(main):002:0> puts "Hello World"
Hello World
=> nil

puts Ruby’de çıktı almak için en basit bir komut. Fakat bu => nil ne oluyor ki? Bu işlevin sonucudur. puts her zaman Ruby’de hiçbir şeyi ifade eden nil değerini döndürür.

Bedava Hesap Makinası Burada

IRB basit bir hesap makinası olarak kullanılabilir:

irb(main):003:0> 3+2
=> 5

Üç artı iki. Çok kolay. Peki üç kere iki nedir? Bunu girebileceğiniz gibi bir önce girdiğiniz satırı yukarı tuşuna basarak tekrar çağırabilirsiniz. Yukarı tuşuna basıp bunu test edin + işaretinin üstüne gidip silin ve * ile değiştirin.

irb(main):004:0> 3*2
=> 6

Sonra üçün karesini bulalım:

irb(main):005:0> 3**2
=> 9

Ruby’de ** “üssü” demenin yoludur. Fakat bir sayının karekökü için ne yapmalı?

irb(main):006:0> Math.sqrt(9)
=> 3.0

Tamam, bu ne demek sizce? Tahmin ederseniz dokuzun karekökü alınmış. Haklısınız fakat daha yakından inceleyelim, en başta bu Math ne ?

Modüller, Kodları Başlıklar Altında Toplar

Math matematik için bir dahili modüldür. Modüller Ruby’de iki hizmet sunarlar. Bir rolü şu: benzer görevler yapan metotları bir grup başlığı altında toplamak. Math içinde ayrıca sin() ve tan() gibi işlevler de vardır.

Sonraki bir nokta işareti, nokta ne yapıyor? Nokta size mesajın alıcısını gösteriyor. Burada mesaj sqrt(9) metot çağrısı, parametresi 9 olan “karekök” alma komutu.

Bu metodun cevabı 3.0 dır. Dikkat ettiyseniz sadece 3 değil. Çünkü birçok karekök işleminin sonucu tamsayı değildir. Bu yüzden işlev kayan noktalı bir sayı geri döndürür.

Peki bazı matematik işlemlerimizin sonucunu hatırlamak istersek? Cevabı bir değişkene atama yaparız.

irb(main):007:0> a = 3 ** 2
=> 9
irb(main):008:0> b = 4 ** 2
=> 16
irb(main):009:0> Math.sqrt(a+b)
=> 5.0

Bir hesap makinası için oldukça yeterli. Klasik Hello World mesajından uzaklaşmaya başladık, geri dönelim.

Eğer parmaklarımızı çok yormadan defalarca “Hello” demek istersek ? Bir metot tanımlamamız gerekiyor!

irb(main):010:0> def h
irb(main):011:1> puts "Hello World!"
irb(main):012:1> end
=> nil

def h kodu ile metot tanımlaması başlar. Bu Ruby’ye adı h olan bir metot tanıtımı (definition) başlattığımızı bildirir. Sonraki satır metodun gövdesini oluşturur. Daha önce gördüğümüz gibi: puts "Hello World". Son satırdaki end Ruby’ye metot tanımlamasını bitirdiğimizi belirtir. Ruby’nin  => nil cevabı da metot tanımlamamızı algıladığını belirtir.

Kısaca Bir Metot Defalarca Yaşar

Şimdi bu metodu birkaç defa çalıştıralım:

irb(main):013:0> h
Hello World!
=> nil
irb(main):014:0> h()
Hello World!
=> nil

Pekala, bu kolaydı. Ruby’de metotları çağırmak için adlarını Ruby’ye söylemek yeterli. Eğer metot bir parametre almıyorsa tüm yapmanız gereken bundan ibaret. Eğer isterseniz boş parantezlerle parametresiz bir metot çağırdığınızı belirtebilirsiniz, ama gereği yok.

Eğer dünyaya değil de bir kişiye merhaba demek istersek ne olacak? Hemen h metodunu bu sefer parametre alacak şekilde tekrar tanımlayalım.

irb(main):015:0> def h(name)
irb(main):016:1> puts "Hello #{name}!"
irb(main):017:1> end
=> nil
irb(main):018:0> h("Matz")
Hello Matz!
=> nil

Çalıştığını gördükten sonra neler olduğunu tekrar bir inceleyelim.

String İçine Erişmek

#{name} kısmı nedir? Bu bir string içine birşeyler eklemenin Ruby yoludur. Süslü parantez içindeki kısım stringe çevrilir ve ana string içine bu noktada eklenir. Bunu verilen ismin ilk harfinin büyük olduğundan emin olmak için kullanabilirsiniz:

irb(main):019:0> def h(name = "World")
irb(main):020:1> puts "Hello #{name.capitalize}!"
irb(main):021:1> end
=> nil
irb(main):022:0> h "chris"
Hello Chris!
=> nil
irb(main):023:0> h
Hello World!
=> nil

Burada birkaç diğer şekil görünüyor. Biri metodu parantez kullanmadan çağırıyoruz. Parantezler keyfe bağlı kullanılır, görsel olarak isterseniz kullanırsınız. Diğer şekil varsayılan parametre değeri World. Bunun anlamı eğer parametre verilmediyse name değeri varsayılan olarak "World"alınacaktır.

Bir Selamlayıcıya Dönüştürmek

Eğer bir selamlayıcı yapmak istersek, adınızı hatırlayacak ve sizi karşılayacak, sonra uğurlayacak. Bunu yapmak için bir nesne kullanmak isteyebilirsiniz. Bir “Greeter” sınıfı oluşturalım.

irb(main):024:0> class Greeter
irb(main):025:1>   def initialize(name = "World")
irb(main):026:2>     @name = name
irb(main):027:2>   end
irb(main):028:1>   def say_hi
irb(main):029:2>     puts "Hi #{@name}!"
irb(main):030:2>   end
irb(main):031:1>   def say_bye
irb(main):032:2>     puts "Bye #{@name}, come back soon."
irb(main):033:2>   end
irb(main):034:1> end
=> nil

Buradaki yeni kelime class. Bu Greeter adı verilen bir nesne ve içinde birkaç metot tanımlar. Ayrıca dikkat ederseniz @name bu sınıfın bir örnek değişkeni. Göreceğiniz gibi say_hi ve say_bye metotları içinde kullanılıyor.

Peki bu Greeter sınıfını nasıl çalıştıracağız? Bir nesne üretin.

Şimdi bir selamlayıcı nesnesi üretelim ve kullanalım:

irb(main):035:0> g = Greeter.new("Pat")
=> #<Greeter:0x16cac @name="Pat">
irb(main):036:0> g.say_hi
Hi Pat!
=> nil
irb(main):037:0> g.say_bye
Bye Pat, come back soon.
=> nil

Bir kez g nesnesi üretildi mi, ismin Pat olduğunu hep hatırlayacaktır. Hımm, peki ismi direkt olarak almak istersek ne olacak?

irb(main):038:0> g.@name
SyntaxError: compile error
(irb):52: syntax error
        from (irb):52

Yok, yapamadık.

Nesnenin Derisinin Altında

Örnek değişkenleri nesnenin içinde gizli kalırlar. Mutlak olarak gizli değillerdir, onlara erişmenin başka yolları vardır, fakat Ruby verileri dışarıdan erişime gizleyecek çeşitli nesne yönelimli teknikler kullanır.

Pekala Greeter nesnesinin ne metotları mevcut?

irb(main):039:0> Greeter.instance_methods
=> ["method", "send", "object_id", "singleton_methods",
    "__send__", "equal?", "taint", "frozen?",
    "instance_variable_get", "kind_of?", "to_a",
    "instance_eval", "type", "protected_methods", "extend",
    "eql?", "display", "instance_variable_set", "hash",
    "is_a?", "to_s", "class", "tainted?", "private_methods",
    "untaint", "say_hi", "id", "inspect", "==", "===",
    "clone", "public_methods", "respond_to?", "freeze",
    "say_bye", "__id__", "=~", "methods", "nil?", "dup",
    "instance_variables", "instance_of?"]

Vay, bir sürü metot varmış. Biz sadece iki metot tanımladık. Burada neler oluyor? Pekala bunlar Greeter nesnesinin tüm metotları, kalıtımdan gelenler dahil. Eğer kalıtımdan gelen atalarının metotlarını görmek istemezsek az evvelki çağrıyı false parametresiyle yapmalıyız. Bunun anlamı kalıtımsal metotları istemediğimizdir.

irb(main):040:0> Greeter.instance_methods(false)
=> ["say_bye", "say_hi"]

Ah, şimdi daha iyi. Haydi şimdide selamlayıcı nesnemiz hangi metotlara cevap veriyor, bulalım:

irb(main):041:0> g.respond_to?("name")
=> false
irb(main):042:0> g.respond_to?("say_hi")
=> true
irb(main):043:0> g.respond_to?("to_s")
=> true

Gördüğünüz gibi say_hi ve to_s (bir şeyi stringe çevirme emridir) kelimelerinin anlamını biliyor, fakat name anlamını bilmiyor.

Sınıfları Değiştirmek—Asla Çok Geç Değildir

Fakat eğer ismi görmek ve değiştirmek isterseniz ne olacak? Ruby nesnenin değişkenlerine erişmek için kolay bir yol sunar.

irb(main):044:0> class Greeter
irb(main):045:1>   attr_accessor :name
irb(main):046:1> end
=> nil

Ruby’de bir sınıfı tekrar açıp değiştirebilirsiniz. Yapılan değişiklikler yeni üretilecek nesnelerde etkili olacağı gibi üretilmiş nesnelerde de etkilidir. Öyleyse yeni bir nesne üretelim ve onun @name özelliği ile biraz oynayalım.

irb(main):047:0> g = Greeter.new("Andy")
=> #<Greeter:0x3c9b0 @name="Andy">
irb(main):048:0> g.respond_to?("name")
=> true
irb(main):049:0> g.respond_to?("name=")
=> true
irb(main):050:0> g.say_hi
Hi Andy!
=> nil
irb(main):051:0> g.name="Betty"
=> "Betty"
irb(main):052:0> g
=> #<Greeter:0x3c9b0 @name="Betty">
irb(main):053:0> g.name
=> "Betty"
irb(main):054:0> g.say_hi
Hi Betty!
=> nil

attr_accessor kullanarak iki yeni metot tanımlanmış olur, değeri okumak içinname ve değeri değiştirmek için name= metotları.

Herşeyi ve Hiçbirşeyi Selamlamak, MegaGreeter Hiçbirini Atlamaz!

Bu selamlayıcı yeterince ilginç değil. Sadece bir kişi ile ilgileniyor. Eğer biz dünyayı, bir kişiyi yada kişiler listesinin hepsini selamlayacak bir MegaGreeter istersek nasıl olacak?

Bu seferki kodumuzu direk IRB’de yazmak yerine bir dosyaya yazarak saklayalım.

IRB’den çıkmak için “quit” veya “exit” yazın ya da sadece Control-D basın.

#!/usr/bin/env ruby

class MegaGreeter
  attr_accessor :names

  # Nesnenin üretilmesi
  def initialize(names = "World")
    @names = names
  end

  # Herkese merhaba de
  def say_hi
    if @names.nil?
      puts "..."
    elsif @names.respond_to?("each")
      # @names içinde bir çeşit liste var, içinde döndür!
      @names.each do |name|
        puts "Hello #{name}!"
      end
    else
      puts "Hello #{@names}!"
    end
  end

  # Herkese hoşçakal de
  def say_bye
    if @names.nil?
      puts "..."
    elsif @names.respond_to?("join")
      # Liste elemanlarını virgülle birleştir
      puts "Goodbye #{@names.join(", ")}.  Come back soon!"
    else
      puts "Goodbye #{@names}.  Come back soon!"
    end
  end

end


if __FILE__ == $0
  mg = MegaGreeter.new
  mg.say_hi
  mg.say_bye

  # İsmi "Zeke" olarak değiştir
  mg.names = "Zeke"
  mg.say_hi
  mg.say_bye

  # İsmi bir isimler dizisine çevir
  mg.names = ["Albert", "Brenda", "Charles",
    "Dave", "Engelbert"]
  mg.say_hi
  mg.say_bye

  #  nil yap
  mg.names = nil
  mg.say_hi
  mg.say_bye
end

Bu dosyayı “ri20min.rb” olarak kaydedin ve “ruby ri20min.rb” konsol komutuyla çalıştırın. Çıktısı şöyle olmalı:

Hello World!
Goodbye World.  Come back soon!
Hello Zeke!
Goodbye Zeke.  Come back soon!
Hello Albert!
Hello Brenda!
Hello Charles!
Hello Dave!
Hello Engelbert!
Goodbye Albert, Brenda, Charles, Dave, Engelbert.  Come
back soon!
...
...

Bu son örnekle birçok yeni şey ortaya çıktı.

Peki, yeni programımıza daha derin bir inceleme yapalım, (#) ile başlayan ilk satıra dikkat edin. Ruby’de diyez işareti ile başlayan satırlar bilgilendirme satırlarıdır ve komut işleyici tarafından dikkate alınmaz. Dosyanın ilk satırının Unix benzeri işletim sistemlerinde özel bir anlamı vardır. İşletim sistemine dosyanın nasıl çalıştırılacağını anlatır. Diğer bütün yorum satırları sadece bilgilendirme amaçlıdır.

Bizim say_hi metodunda biraz kurnazlıklar mevcut:

# Herkese merhaba de
def say_hi
  if @names.nil?
    puts "..."
  elsif @names.respond_to?("each")
    # @names içinde bir çeşit liste var, içinde döndür!
    @names.each do |name|
      puts "Hello #{name}!"
    end
  else
    puts "Hello #{@names}!"
  end
end

Bu betik nasıl cevap vereceğine karar vermek için @names değişkenine bakıyor. Eğer değişken boşsa üç nokta koyuyor, selamlanacak kimse yoksa ne yapacak ki?

Çevirmek, Döngü veya Yineleme

Eğer @names nesnesi each metoduna cevap verirse içinde yineleme yapabileceğiniz bir listedir, öyleyse onun içinde bir yineleme ile listedeki her kişiyi selamlayabilirsiniz. En son olarak da @names bunların hiçbiri değilse otomatik olarak stringe dönüşür ve önceki selamlama şeklini yapar.

Haydi bu yineleyiciyi daha yakından inceleyelim:

@names.each do |name|
  puts "Hello #{name}!"
end

each metodu arkasından gelen kod bloğunu listenin her elemanı için çalıştırır. do ve end arasında kod bloğu yer alır. Liste elemanları tek tek bar karakterleri arasındaki değişkene konur ve kod işlenir. Sonra bir sonraki liste elemanına geçilir.

Eğer isimleri bir liste içinde verirseniz ne olacak? name listenin elemanlarına bağlanır ve puts "Hello #{name}!" satırı bu isimle çalışır.

Birçok diğer programlama dilinde bir liste for döngüsü ile işlenir, C’de şuna benzer bir kod olur:

for (i=0; i<number_of_elements; i++)
{
  do_something_with(element[i]);
}

Bu kod çalışıyor ama şık bir görüntüsü yok. i gibi bir değişken üretmek zorundasınız, listenin uzunluğunu bulmak zorundasınız ve liste elemanlarının nasıl işleneceğini anlatmak zorundasınız. Ruby yolu çok daha zarif, tüm ayrıntılar bir each kelimesinin içinde saklı ve sadece her elemanı ne yapacağınızı anlatmak zorundasınız. Ayrıca daha okunaklı oluyor, Ruby yolu böyle olmalı. İçeride each metodu sırayla yield "Albert" sonra yield "Brenda" sonra yield "Charles" şeklinde çalışmaktadır.

Bloklar, Ruby’nin En Işıldayan Özelliği

Blokların bir şeyleri işlemekteki gücü listelerden daha karmaşıktır. Metodun içerisindekileri toparlamanın ötesinde, ayrıca kullanıcı farkında olmadan ayarlarlar, parçalama ve hatalarla ilgilenebilirsiniz.

# Herkese hoşçakal de
def say_bye
  if @names.nil?
    puts "..."
  elsif @names.respond_to?("join")
    # Liste elemanlarını virgülle birleştir
    puts "Goodbye #{@names.join(", ")}.  Come back soon!"
  else
    puts "Goodbye #{@names}.  Come back soon!"
  end
end

say_bye metodu each kullanmaz onun yerine @names değişkeninin joinmetoduna cevap vermesini sınar ve kullanır. Diğer durumda liste değil de string olarak işlenir. Bu metot, değişkenin orjinal tipi ile ilgilenmez joinmetoduna cevap veriyorsa join ile değişkeni işler, liste değil başka bir tipte değişken de join metoduna cevap verse onu da aynı şekilde işler. Buna “Duck Typing” denir, “eğer ördek gibi yürüyorsa ve ördek gibi ötüyorsa …” gibi bir şey.

Betiğe Giriş

Peki, bu MegaGreeter sınıf tanımıydı, dosyanın geri kalanı ise bu sınıfın kullanılmasından ibaret. Dikkatinizi çekecek son bir nokta kaldı, o da şu:

if __FILE__ == $0

__FILE__ sihirli bir değişkendir ve bulunduğu dosyanın ismini içerir. $0 ise bu programı çağıran dosyanın ismini içerir. Buradaki koşul ile “Eğer bu dosya direk çağrıldıysa .. ” deniyor. Başka bir program burada tanımlanan sınıfırequire satırı ile içerip kullanacaksa bu koşul içindeki blok çalışmayacaktır. Ancak ve ancak bu dosya tek başına çalıştırıldığında bu satırlar işlenecekir.

Artık Kendinizi Tanışmış Kabul Edin

Ruby’ye hızlı bakış bu kadar. Daha Ruby’nin sunduğu incelenebilecek birçok değişik kontrol yapıları var; blokların ve yieldin kullanımı, modüller ve dahası. Umarız bu anlattıklarımız sizde Ruby hakkında daha fazla şeyler öğrenmek için bir arzu yaratmıştır.

Gerçekten kapsamlı bir kitap bakıyorsanız, kitap listesinde yararlı kitaplar bulabilirsiniz.

Referanslar

• Rubby Web Sayfası