Tek dosyada Ruby Programlama Dilinin Temellerini Öğren ve Dene. Çalıştırılabilir Betik dosyası

ruby_ogren.rb

# coding: utf-8

# Tek satırlık yorum yazmak için # kullandık
# Version: Ruby-2.4.1

=begin
Ruby Programlama Dili, 1995 itibariyle yayınlaşmış,
Matsumoto Yukihiro (Japoncada soyad önce söylenir)
tarafından geliştirilmeye başlanmış özgür bir projedir.
Bu da bir çok satırlı yorumdur.
=end

# Her şeyden önce: Her şey bir NESNEDİR!

p 3.class # => Integer # 2.4 öncesi Fixnum
p "3".class # => String

# Temel aritmetik işlemleri
toplama = 2 + 2
cikarma = 6 - 6
carpma = 2 * 4
bolme = 75 / 5
us_alma = 4 ** 2
modul_alma = 4 % 2

puts "ARİTMETİK İŞLEMLER"
puts "Toplama: 2 + 2 = ", toplama
puts "Çıkarma: 6 - 6 = ", cikarma
puts "Çarpma: 2 * 4 = ", carpma
puts "Bölme: 75 / 5 = ", bolme
puts "Üs Hesaplama: 4 ** 2 = ", us_alma
puts "Mödül: 4 % 2 = ", modul_alma
# Ekran çıktısında da göreceğiniz üzere puts aldığı her değerin sonuna
# bir \n karekteri yani yeni satır bildirimi ekliyor ve  bunun sonucunda da
# puts "Toplama: 2 + 2 = ", toplama çıktısı
# Toplama: 2 + 2 =
# 4
# oluyor. Bu durumun oluşmaması için print kullanabiliriz.
print "Toplama: 2 + 2 = ", toplama, "\n"
print "Çıkarma: 6 - 6 = ", cikarma, "\n"
print "Çarpma: 2 * 4 = ", carpma, "\n"
print "Bölme: 75 / 5 = ", bolme, "\n"
print "Üs Hesaplama: 4 ** 2 = ", us_alma, "\n"
print "Mödül: 4 % 2 = ", modul_alma, "\n"

# Bit işlem operatörleri
bit_islem_ampersand = 3 & 5
bit_islem_or = 3 | 5
bit_islem_xor = 3 ^ 5

puts "BİT İŞLEM OPERATÖRLERİ"
print "& Operatörü: 3 & 5 = ", bit_islem_ampersand, "\n"
print "| Operatörü: 3 | 5 = ", bit_islem_or, "\n"
print "^ Operatörü: 3 ^ 5 = ", bit_islem_xor, "\n"

# Aritmetik işlem operatörleri esasında bir method çağrısıdır
aritmetik_operator_cagrisi = 2.+(2)

puts "Nesneden sonra . koyarak o nesnenin methodunu çağırabiliriz. () içerisine da parametre alır: 2.+(2)", aritmetik_operator_cagrisi

# Özel değerler de birer nesnedirler
ben_bir_nil_degerim = nil # ki kendisi diğer dillerdeki null değerinin karşılığıdır
ben_dogruyum = true # Doğru: Diğer dillerden farklı olarak 0 da "" gibi boş string ya da boş dizi vs true bir değerdir.
php_rubyden_iyidir = false # Yanlış

puts "MANTIKSAL DEĞERLER"
puts "Doğru: #{ben_dogruyum}\nYanlış: #{php_rubyden_iyidir}\nNil: #{ben_bir_nil_degerim}" # string interpolation için: #{} Ayrıca \n yeni satır başlatır

puts "nil nesnesinin sınıfı: ", nil.class
puts "true nesnesinin sınıfı:", true.class
puts "false nesnesinin sınıfı: ", false.class

# KARŞILAŞTIRMA OPERATÖRLERİ
# Eşitlik ==
# deger == diger_deger # => true ya da false döner
print "2 == 2 # => ", 2 == 2, "\n" # => true
print "4 == 2 # => ", 4 == 2, "\n" # => false

# Eşit Olmama !=
# deger != diger_deger # => true ya da false döner
print "1 != 1", 1 != 1, "\n" #=> false
print "2 != 1", 2 != 1, "\n" #=> true

# false nesnesinin kendisi hariç nil falsey değerli tek nesnedir # => diğer her şey true döner
puts "not ya da ! operatörü mantıksal değerin tersini döndürür :)"
puts " not 0: ", !0 # => false # Sıfırın değili(not) diğer bir ifade ile ! false çünkü sıfırın kendisi true
puts "!false: ", !false # => true
puts "!nil: ", !nil # => true

# Büyüklük karşılaştırmaları
puts "1 > 1000 #=> ", 1 > 100 # => false
puts "1 > 0 #=> ", 1 > 0 # => true
puts "1 < 100 #=> ", 1 < 100 # => true
puts "1 < 0 #=> ", 1 < 0 # => false

# Kombine karşılaştırma operatörü
puts "1 <=> 2", 1 <=> 2 # => -1 # başka bir değişle 1 in sırası 2 den öncedir
puts "2 <=> 1", 2 <=> 1 # => 1
puts "1 <=> 1", 1 <=> 1 # => 0

# Mantıksal operatörler
puts "true && false", true && false # => false # && ancak iki taraf da true ise true döner
puts "true || false", true && false # => true # || ancak iki taraf da false ise false döner
puts "!true", !true # => false
puts "!false", !false #=> true

# Soru işareti ile biten methodlar true ya da false döner
puts "2 çift mi?", 2.even?
puts "2 tek mi?", 2.odd?
puts "3 çift mi?", 3.even?
puts "3 tek mi?", 3.odd?


# MANTIKSAL OPERATÖRLERİN ALTERNATİFLERİ
# && için: and
# || için: or
# ! için: not

# String veri türü de bir NESNEDİR!
abbas_string = "Ben, bir koca string, aynı zamanda nesneyim. Yaaaaa, naber!"
puts "'Ben, bir koca string, aynı zamanda nesneyim. Yaaaaa, naber!' string nesnesinin sınıfı: ", abbas_string.class

# "" işeretleri içerisinde tanımlanmış string içinde string interpolation ve özel ifadeler dikkate alınır: \n ifadesi gibi
# '' işaretleri içerisinde tanımlanmış string ham bir string olarak değerlendirilir
nedir_bu_string_interpolation = "Herkese benden bir string interpolation"
puts "#{nedir_bu_string_interpolation} ama Şakir'e string interpolation yok!"

# String interpolation benzeri bir kullanım olmadıkça '' tercih edin
# Stringleri birbiri ile birleştirebiliriz
# ama bir sayı ile doğrudan birleştiremeyiz
ismim = 'Gökhan ' + 'ÇAĞLAR' # Bu doğru bir kullanım
# ama 'yaşım: ' + 35 TypeError hatası döndürecektir
# to_s metodu ile bir sayıyı string olarak dönüştürebiliriz
yasim = 'yaşım: ' + 35.to_s

puts "Merhaba, benim ismim #{ismim} ve #{yasim}"

# Ancak * operatörü ile stringler tamsayılarlarla etkileşebilir
cs_1_6 = 'Go! ' * 3

puts "In game start: ", cs_1_6

# String nesneleri << (shovel operatörü de denir) birleştirebiliriz
el_classico = "Merhaba, " << "Dünya!"

puts el_classico

# puts (ki put string olarak düşünün açılımını) değerinin sonuna bir yeni satır başlangıcı ekler: \n
puts "Aşağıdakilerden hangisi aşağıdadır: "
puts "Kendinden sonra gelen string çıktıları aşağılıyorsun demek!"

# print ise stringin işine veya sonuna karışmaz diyelim
print "Benim adım: "
puts "Gökhan ÇAĞLAR, benden sonrası"
puts "yeni satır!"

print "\\n den sonrası\nda yeni satır ama burdan sonrası "
print "yeni satır değil :("

puts "" # yeni satır

# DEĞİŞKENLER
# = işareti ile bir isme bir değeri atarız böylece o isim o değeri referans gösterir
bir = 1 # bir isimli değişkene 1 tamsayı değerini atadık
puts "bir isimli değişkenin değeri: ", bir
yedi = bir + 6

puts "1 + 6 = ", yedi

# Bir değişken adı uzadıkça yılan gibi uzar
bir_degisken_adi_uzadikca_yilan_gibi_uzar = "bir_degisken_adi_uzadikca_yilan_gibi_uzar = ama siz yine de 'Aydın Havası' gibi kısa kesin."

puts bir_degisken_adi_uzadikca_yilan_gibi_uzar

# Oluşturdunuz değişken adları açıklayıcı olsun
# 2.4 sürümü ve sonrasında Türkçe karakterleri değişken adlarında sorunsuz kullanabilirsiniz
# ancak tavsiye etmem
kalbe_giden_yol = "sevgi ve saygı"
yolun_gectigi_yer = kalbe_giden_yol + "dan"
kimin_kalbine_giden_yol = "Benim kalbime giden yol" 
puts "#{kimin_kalbine_giden_yol} #{yolun_gectigi_yer} geçer."

# Semboller (symbol) Ruby dilinin kendine has veri türüdür
# Semboller değiştirilemez(immutable) tekrar kullanılabilen
# içerdikleri bir tamsayı değer ile gösterilen sabitlerdir.
durum = :beklemede
print "Durum değişkeni :beklemede sembolune refarans ve sınıfı: ", durum.class, "\n"
print "durum == 'beklemede' # => ", durum == 'beklemede', "\n" # 'beklemede' stringi ile :beklemede sembolu aynı şey değildir

# DİZİLER
# Diziler aynı veya farklı türlerde bir veya birden fazla değeri içeren değer serileridir diyebiliriz
# dizi itemleri [] işaretleri içerisinde tanımlanır.
# İçerilen değerler 0'dan başlayıp endekslenerek tutulur ve bir dizideki değere endeks sayısı ile erişiriz
# dizi[0] # => dizinin içerisinde tutulan ilk değeri döner
dogum_tarihi = [1982, 1, 4]

print "Doğum yılım: ", dogum_tarihi[0], "\n"

en_sevdigim_diziler = [1, 'Doctor Who', 2, 'American Gods', 3, 'Game Of Thrones', 4, 'Orange Is New Black']
puts "Sırası ile en sevdiğim diziler".upcase # upcase methodu string içerisindeki bütün karakterleri büyük harf yaptı
print "#{en_sevdigim_diziler[0]}. sırada #{en_sevdigim_diziler[1]}, "
print "#{en_sevdigim_diziler[2]}. sırada #{en_sevdigim_diziler[3]}, "
print "#{en_sevdigim_diziler[4]}. sırada #{en_sevdigim_diziler[5]}, "
print "#{en_sevdigim_diziler[6]}. sırada #{en_sevdigim_diziler[7]} isimli dizilerdir.\n"

kostekli_saat = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# Soldan sağa dizi endeksini almak
puts "kostekli_saat isimli değişkende tutulan dizinin ilk değeri: ", kostekli_saat[0] # => 1
puts "kostekli_saat isimli değişkende tutulan dizinin ilk değeri: ", kostekli_saat.first # => 1
# [] sadece bir method çağrısıdır yani şöyle de yazılabilir:
puts "kostekli_saat isimli değişkende tutulan dizinin ilk değeri: ", kostekli_saat.[](0) # => 1

# Sağdam sola dizi endeksini almak
puts "kostekli_saat isimli değişkende tutulan dizinin son değeri: ", kostekli_saat[-1]
puts "kostekli_saat isimli değişkende tutulan dizinin son değeri: ", kostekli_saat.last
puts "kostekli_saat isimli değişkende tutulan dizinin son değeri: ", kostekli_saat.[](-1)

# Eğer dizi sınırları dışına çıkarsak nil değeri döner
print "Dizinin sınırları dşındaki bir endeksin değerini sorgularsak dönen: ", kostekli_saat[13], "\n" # => nil

# Dizlerin belli bir aralığını almak istersek
# dizi[başlangıç_endeksi, alınacak item sayısı]
print "3. endeksten itibaren 5 item al: ", kostekli_saat[3, 5], "\n" # => [4, 5, 6, 7, 8]

# Bir diziyi tersine çevirme
# değişiklikleri değişken değerinin üzerine yazdıran için method ismi sonunda ! işareti bulunur
print "Diziyi tersine çevirdik: ", kostekli_saat.reverse, "\n"

dijital_saat = [24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13]
# String ile olduğu gibi << operatörü diziye değer eklemek için kullanılabilir
dijital_saat << kostekli_saat.reverse # => [24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
dijital_saat.reverse!
print "dijital_saat: ", dijital_saat, "\n"
print "kostekli_saat: ", kostekli_saat, "\n"

# range ile de bir dizideki değerler aralığını döndürebiliriz
print en_sevdigim_diziler[0..4], "\n" #  Sıfırdan başlayarak 4. iteme kadar bir dilim aldık

# item eklemek için push method çağrısını da kullanabilirsiniz
en_sevdigim_diziler.push(5)
en_sevdigim_diziler.push("Lost Room")

# Bir dizinin bir değeri içerip içermediğini include?() method çağrısı ile kontrol ederiz
puts "kostekli_saat 12 değerini içeriyor mu? ", kostekli_saat.include?(12) # => true
puts "kostekli_saat 24 değerini içeriyor mu? ", kostekli_saat.include?(24) # => false

# pop() ile dizinin sonundaki itemi silebiliriz
# shift() ile dizinin ilk itemini sileriz
# unshift() ile dizinin başlangıcına item ekleriz
# ya da dizi[endeks_numarasi] = deger şekilnde item eklenebilir

# Ruby Dilinde anahtar => değer eşleştirmeleri hash olarak adlandırlılır
# hash itemleri {} işaretleri içerisinde tanımlanır.
canta = {"renk" => "siyah", :hammadde => "deri", "adet" => 1}
print "canta degişkenine atanan hash: ", canta, "\n"

# değerlere erişmek için [] method çağrısına anahtar değer parametre olarak verilir
puts "çanta hash değişkenindeki değerler".capitalize # capitalize method çağrısı ile string içindeki her bir kelime grubu büyük harf ile başlayacak
puts "Çanta rengi: ", canta["renk"]
print "Bu bir ", canta[:hammadde], " çanta", "\n"
puts "Çanta Adedi: ", canta["adet"]

# Sembolleri anahtar olarak tanımlamak hem daha pratik hem daha performanslıdır
musteri = {isim: "Gökhan", soyad: "ÇAĞLAR", yas: 35}
print "Müşteri: ", musteri, "\n"
print "Müşteri Adı: ", musteri[:isim], "\n"

# Var olmayan bir anahtarı sorgularsak nil değeri döner
puts musteri[:super_power] # => nil

# Değer eklemek için
musteri[:super_power] = 'Uçmak'
  
puts musteri[:super_power]

# İki farklı hash değerini birleşitirmek için merge() method çağrısı kullanılabilir

# keys methodu HASH içerisindeki anahtarları dizi olarak döner
print "musteri için anahtar değerleri: ", musteri.keys, "\n"
# haliyle values methodu da hash içerisindeki değerleri dizi olarak döner

# Bir hash içinde anahtar ya da değerin var olup olmadığı kontrol edilebilir.
puts "musteri değişkeninde :isim anahtarı var: ", musteri.key?(:isim)
puts "musteri değişkeninde 'Gökhan' değeri var: ", musteri.value?('Gökhan')

# Hem diziler hem hashler Enumerable verilerdir
# Enumerable modülünden pek çok methodla enumarator döndürebilirler
# başlıcaları: each, each_with_index, each_pair, map, count, reduce, inject
# İleride değinmeye çalışacağım

# Akış Kontrolleri
#if true
#  "Bu blok çalıştırılacak"
#elsif baska_bir_true
#  "bu blok çalıştırılacak"
#else
#  "hiç biri olmazsa bu blok çalıştırılacak"
#end

bir_deger = 18

if bir_deger > 16 && bir_deger < 18
  puts "Ehliyet alabilir ama bara gidemez."
elsif bir_deger < 16 && bir_deger >= 12
  puts "Ergenlik zor zanaat"
elsif bir_deger < 12
  puts "Gezme ve oyun zamanları"
else
  puts "Ne isterse yapar"
end

# Ruby dilinde if not true ifadesine alternatif olarak unless true ifadesi vardır
# unless genellikle else içermeyen durumlara karışılık kullanılır

# Bir akış kontrolünün döndüğü değer bir değişkene atanabilir
kisi = 'Gökhan'
izlenim = if kisi == 'Gökhan'
            'Yakışıklı'
          else
            'Eh!'
          end

# RUby tenarry operatorunu destekler
detay = kisi == 'Gökhan' ? 'akıllı' : 'Zamanla Anlaşılır'

puts "#{kisi} #{izlenim} ve #{detay} bir adam."

# Iterasyon
# for ile bir dizi ya da range itemleri ile iterasyon yapılabilir
for sayac in 1..10
  puts "Saklanbaç: #{sayac}"
end

# => Saklanbaç: 1
# => Saklanbaç: 2
# => Saklanbaç: 3
# => Saklanbaç: 4
# => Saklanbaç: 5
# => Saklanbaç: 6
# => Saklanbaç: 7
# => Saklanbaç: 8
# => Saklanbaç: 9
# => Saklanbaç: 10

# range oluşturuken ... kullanırsanız son değer hariç tutulur
# örnek: (1...9) # Son Enumarator Değeri: 8
# to_a method çağrısı ile range bir diziye dönüştürülebilir

# each dizilerin, rangelerin vb. her bir itemini bir kere blok içerisinde döndürür
# bir blok kod grubu alanı olarak düşünülebilir
(1...6).each do |sayac|
  # sayac sozde değişkeni sadece blok içerisinde varlığını sürdürür
  puts "Sayaç: #{sayac}" 
end

# => Sayaç: 1
# => Sayaç: 2
# => Sayaç: 3
# => Sayaç: 4
# => Sayaç: 5

# while ile klasik bir döngü oluşturabilirsiniz
# continue ifadesi yerine next kullanılır
# break ile döngüden çıkılabilir
bir_sayac = 0
baska_bir_sayac = 10

while bir_sayac < 10
  print "#{bir_sayac} "
  bir_sayac += 1
end

puts # Yeni satır

# Sonsuz döngü
loop do
  print "#{baska_bir_sayac} "
  baska_bir_sayac -= 1
  break if baska_bir_sayac == 0 
end

# Ayrıca while not true alternatifi olarak until true kullanılabilir



# {} içerisinde de kod bloğu oluşturulabilir

dizi = (1..20).to_a

print "dizi değişkeninin sınıfı: ", dizi.class, "\n"

dizi.each { |sayac| puts "Başka Bir Sayaç: #{sayac}" }

# Ruby Dili daha önce de belirttiğim gibi pek çok döngü methodu barındırır
baska_bir_dizi = [3, 5, 7, 9, 11]
katmerlendi = baska_bir_dizi.map { |i| i * 2 }

print "Dizi: ", baska_bir_dizi, "\n"
print "Katmerlenmiş değerler dizisi: ", katmerlendi, "\n"

# Switch case mahdumlarına gelsin: case
# Evet! Ruby Dilinde case var
puan = 'C'

case puan
when 'A'
  puts "Aferin len!"
when 'B'
  puts "Üzülme! hiç kötü değil..."
when 'C'
  puts "Gelecek sefere daha iyisini yaparsın"
when 'D'
  puts "'Beterin beteri var!'"
when 'E'
  puts "ÇALIŞ BİRAZ!"
when 'F'
  puts "KALDIN!"
else
  puts "Yalnış not sistemine göre not girişi yaptın!"
end

# HATA YAKALAMA
# Ruby Dili de c#, java ve python vb. dilleri gibi
# Error Handling imkanı sunar
begin
  # Burada bir hata raise edelim
  raise TypeError, 'Bu ne biçim tip yahu!'
rescue TypeError => exception_degiskeni
  puts 'Tip hatası döndü ama yakaldım. Hey be tipini seveyim!', exception_degiskeni
rescue RuntimeError => diger_exception_degiskeni
  puts 'RuntimeError varsa ben yakalarım abi', diger_exception_degiskeni
else
  puts 'Hiç bir hata yakalanmadı ama ben yine de hatasız kul olmaz mesajımı yazacağım. Hata varsa ben susacağım.'
ensure
  puts 'Hata olsa da olmasa da ben çalışırım arkadaş.'
end

# Fonksiyonlar ve diğer tüm bloklar içerdikleri son satırdaki değeri dönerler
# Ruby Dilinde isimsiz fonksiyon tanımlamaları oluşturmak için Proc ve Lambda vardır
# Proc lambdadan farklı olarak fazladan gelen parametre varsa dikkate almaz ve hata döndürmez
# p = Proc.new { |x| x * 2 }
# Ruby dilinde bir fonksiyon ya da lambda ya da proc değişkene atanabilir
# Çağrılarda parametre vermek için degisken_adi[paramatre] ya da degisken_adi.call(parametre)
# sözdzimi kullanılır
katmerle = ->(x) { x * 2 } # LAMBDA

puts katmerle[4] # Lamba çağırma yollarından biri. Diğeri: katmerle.call(4)

# Fonksiyonlar def ifadesi ile tanımlanır ve end ile sonlanırlar
def ikile(x)
  x * 2
end

puts ikile(8)

# İç içe çağrı
puts ikile(ikile(8))
puts katmerle.call(katmerle[16])

def topla(x, y)
  x + y
end

puts topla(80, 48)
puts topla(topla(80, 48), 128)


# yield
# Tüm methodlar kendiliğinden optional bir blok parametresi kabul eder
def eko
  puts '*' * 40
  10.times { yield }
  puts '*' * 40
end

eko { puts 'EKO!' }

# Bir fonksiyona parametre olarak blok geçebilirsiniz
# & kendinden önce bu ampersand işareti ile belirtilir
mesaj = ->(x) { puts "Merhaba, #{x}!" }

def selamla(&msj)
  msj.call 'Dünya'
end

selamla(&mesaj)

# Önceden tahmin edemeyeceğimiz sayıda argüman alacaksa fonksiyon
# * işareti ile seri argüman geçebiliriz
def beyaz(*args)
  args.each { |konuk| puts "O biivvv #{konuk}" }
end

# Pythonda olduğu gibi birden fazla öngörülemeyen sayıda anahtar değer parametre göndermek de mümkündür
def anahtarlar_degerler(**kvargs)
  kvargs.each_pair do |k, v|
    puts "Anahar: #{k} => Değer: #{v}"
  end
end

  eski_bir_hash = {birinci: 1914, ikinci: 1945}

  anahtarlar_degerler(**eski_bir_hash)

# Dizi dönen bir methodu parelel atama için kullanabilirsiniz
def muhtesem_uclu
  ['Metin', 'Ali', 'Feyyaz']
end

m, a, f = muhtesem_uclu

puts m, a, f

# SINIFLAR
class Insan
  attr_accessor :isim # isim için gether ve sether otomatik oluşturulacak
  
  # attr_reader sadece getter oluşturur
  # attr_writer sadece setter oluşturur
  
  @@tur = 'Homo Sapiens'
  @@nufus = 0

  # Nesne inşa edici
  def initialize(isim, yas = 0)
    @isim = isim
    @yas = yas
    @@nufus += 1 # @@nufus = @@nufus + 1 ifadesinin kısa yazımı
  end

  # Setter method
  def yas=(y)
    if y.is_a?(Integer) && y > 0
      @yas = y
    else
      puts "Lütfen sıfırdan büyük bir tamsayı giriniz!"
    end
  end

  # getter method
  def yas
    @yas    
  end

  # Bir sınıf methodu self kullanılarak tanımlanır
  # Instance üzerinden değil doğrudan sınıf üzerinden çağrılabilir
  def self.der_ki(msj)
    puts msj
  end

  def self.nufus
    @@nufus    
  end

  # Bir instance method nesne örneği üzerinden çağrılır
  # Nesnenin davranışıdır
  def tur
    @@tur
  end
  
end

# Bir mesme inşa edelim
ust_insan = Insan.new('Gökhan ÇAĞLAR')
insan = Insan.new('Şakir')
insan.isim = 'Şener'
puts insan.isim
ust_insan.yas = 'Otuz beş'
puts ust_insan.yas
ust_insan.yas = 35
puts ust_insan.yas
ust_insan.tur

# Bir sınıf methodu çağıralım
Insan.der_ki('Seviyorsan git konuş bence.')
puts Insan.nufus

# Moduller
# Moduler diğer dillerdeki name space gibi kullanılabilir
# İçlerinde başka sınıfları, methodları ve hatta modulleri de barındırabilir
# Ruby Dili çoklu kaltımı kullanmadığından Mixin oluşturmada da kullanılabilirler
module BildiginNameSpace
  def foo
    'bar'
  end

  def bar
    'baz'
  end
end

# Değişken tanımlamalarında gördüğümüz @ işareti o değişkenin bir sınıf niteliği değişkeni yani iinstance variable olduğunu belirtir
# Aynı şekilde değişken isminin başına $ işareti koyarak bir global değişken tanımlayabiliriz.
# @@ işareti ile de bir sınıf değişkeni tanımlarız (javadaki ya da c# dilindeki static gibi düşünebilirsiniz)
# Ruby dilinde sınıfın kendisi de bir nesnedir.

# Kalıtım
class Isci < Insan
  include BildiginNameSpace
  attr_reader :is
  def initialize(isim)
    super
    @is = 'Tamirci çırağı'
  end
end

class Usta < Isci
  def initialize(isim)
    super
    @is = 'Tamirci'
  end
  def emir
    puts 'Oğlum!.. al takımları :)'    
  end
end


cem = Isci.new('Cem')
usta = Usta.new('Karaca')

puts cem.is
puts usta.is
usta.emir
cem.yas = 40
cem.yas = 'sonsuz'
usta.yas = 50
usta.yas = 'yaşlı'

puts "Yaş niteliklerini bir kontrol edelim"
print 'Cem Yaş: ', cem.yas, "\n"
print 'Usta Yaş: ', usta.yas, "\n"

puts 'Moduldeki methodları çağıralım'
puts cem.foo
puts usta.bar

# include ve extend
# Bir sınıfa modulu include ile aktarırsak o sınıfın örnekleri de module erişebilir

module BirBaskaNameSpace
  def self.included(base)
    base.extend(ClassMethods)
    base.send(:include, InstanceMethods)
  end

  module ClassMethods
    def baz
      'foo bar baz'
    end
  end

  module InstanceMethods
    def barbaz
      [:bar, :baz]
    end
  end
end

class BilmemBirSey
  include BirBaskaNameSpace
end

BilmemBirSey.baz
# BilmemBirSey.barbaz # => NoMethodError: undefined method 'barbaz'
# BilmemBirsey.new.baz NoMethodError: undefined method 'baz'
BilmemBirSey.new.barbaz # => [:bar, :baz]