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

Burda 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.

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

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

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?"]

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

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

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

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

#!/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

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!
...
...

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 join metoduna 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 join metoduna 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.

Eğer öyleyse lütfen Belgeler bölgesindeki ücretsiz el kitapları ve öğreticileri inceleyin.

Ya da gerçekten kapsamlı bir kitap bakıyorsanız, kitap listesinde yararlı kitaplar bulabilirsiniz.

Bu yazı ruby-lang'tan alınmıştır.