Ruby/Operatörler

Operatörler

1. Atamalar

Ruby'de atamalar eşit işlemcisi "=" kullanılarak yapılır. Bu nesnelerde de değişkenlerde de böyledir, çünkü Ruby'de stringler, floatlar, integerlar hepsi nesnedir ve siz her zaman nesnelere atama yaparsınız.

Örnekler:

  myvar = 'myvar değişkeni şimdi bu string'
  var = 321
  dbconn = Mysql::new('localhost','root','password')

Kendine Atamalar

 x = 1           #=>1
 x += x          #=>2
 x -= x          #=>0
 x += 4          #=>x 0 ise x= + 4 # x değeri 4 olur
 x *= x          #=>16
 x **= x         #=>18446744073709551616 # 16 üssü 16
 x /= x          #=>1

C ve C++ bilenlerden sık gelen bir soru "Bir değişkenin artırım ve azaltımı nasıl yapılacak? ++ ve -- işlemleri nasıl yapılır?" Ruby'de x+=1 artırma için x-=1 azaltım için kullanılır.

 x = 'a'
 x.succ!         #=>"b" : succ! metodu String için tanımlanmıştır ama sayılarda yoktur.

Çoklu Atamalar

Örnekler:

 var1, var2, var3 = 10, 20, 30
 puts var1           #=>var1 değeri 10
 puts var2           #=>var2 değeri 20,var3...etc
 
 myArray=%w(John Michel Fran Adolf) # %w() array tanımlamayı kolaylaştırmak için kullanılır
 var1,var2,var3,var4=*myArray
 puts var1           #=>John
 puts var4           #=>Adolf

 isimler,okul=myArray,'Sen Bernar'
 isimler               #=>["John", "Michel", "Fran", "Adolf"]
 okul              #=>"Sen Bernar"

Koşullu Atama

 x = nil #=>nil
 x ||= "default"      #=>"default" : x nil veya false değerdeyse "default" değerini alacaktır
 x ||= "other"        #=>"default" : x değeri artık nil veya false olmadığı için değişmeyecektir

||= operatörü aşağıdakinin kısaltılmışıdır:

x = x || "default"

||= operatörü şu kodun kısaltılmışı olarak kullanılabilir:

 x = "default" if x.nil?

Bakışlar (Scope)

Ruby'de temel olarak yerel bakış, genel bakış, ve sınıfsal bakış olarak değişkenler işlenir.

Örnek:

 var=2
 4.times do |x| puts x=x*var end  #=>0,2,4,6
 puts x #=>undefined local variable or method `x' for main:Object (NameError)

Bu hata oluşur çünkü ikinci satırdaki x(üst seviye) do..end bloğu içindeki x(yerel) ile aynı değildir. Yerel x blok içinde tanımlanmış bir değişkendir bu yüzden biz blok dışında x değişkeni çağırdığımızda Ruby tanımadığını belirtecektir.

 4.times do |$global| $global=$global*var end  #=>0,2,4,6 $global değişkenine yapılan son atama 6
 puts $global

Bu çalışır çünkü bir değişken adının önüne dolar işareti koymak onu global yapar. Global değişkenleri az kulanıp bu tip yerlerde :

 4.times do |@instvar| @instvar=@instvar*var end  #=>0,2,4,6 @instvar değişkenine yapılan son atama 6
 puts @instvar

@instance_variable, neyin değişkenidir? En üst seviyenin yani 'Main' sınıfının bu oturum için oluşumuna aittir. Bu da $variable gibi global bir etki yapar. Oluşum değişkenleri bir sınıfın oluşumu içinde kullanılır. Yukardaki örnekte sınıf oluşumu tanımlamasını görmüyoruz ama normalde Ruby'de herhangi bir sınıf içinde yazılmayan her kod aslında 'Main' sınıfı denen ana bir sınıf oluşumu içinde çalışır.

 class Test
   def initialize(arg1='kiwi')
     @instvar=arg1
     @@classvar=@instvar+' size cevap veriyor!!'
     localvar=@instvar
   end
   def print_instvar
     puts @instvar
   end
   def print_localvar
     puts @@classvar
     puts localvar
   end
 end
 class SubTest < Test
   def print_classvar
     puts @@classvar
   end
 end
 var=Test.new
 var.print_instvar              #=>"kiwi", bu çalışır çünkü @instvar değişkenine tüm sınıf içinde ulaşılabilir
 var.print_localvar             #=>undefined local variable or method `localvar' for #<Test:0x2b36208 @instvar="kiwi"> (NameError).

Burda önce "kiwi size cevap veriyor!!" yazar sonra çakılır. 'localvar' adındaki değişkeni tanımadığını belirten bir mesaj verir. (NameError). Neden? çünkü 'print_localvar' metodunun tanımı içinde 'localvar' değişkeni tanımlanmamıştır. Sınıfın 'initialize' metodunun tanımında 'localvar' tanıtılmıştır fakat bu tanım içinde yerel değişken olduğundan diğer metod tanımlamaları ona ulaşamaz. Diğer yandan sınıf değişkenleri '@@classvar' ve '@instvar' tüm sınıf içinde erişilebilir. @@classvar sınıf değişkeni bu sınıftan türetilen diğer sınıflara bile ulaşır.

 class SubSubTest < Test
   def print_classvar
     puts @@classvar
   end
   def modify_classvar
     @@classvar='kiwi kiwi waaai!!'
   end
 end
 newvar=SubTest.new              #newvar üretildi ve Test sınıfının bir oluşumu olarak aynı değere sahip bir @@classvar içeriyor!!
 newvar.print_classvar           #=>kiwi size cevap veriyor!! 

Sınıf değişkenleri sınıf ve altsınıflarında görülür. Bu değişkenler altsınıfa geçtikleri gibi altsınıfın hareketlerinden de etkilenirler ;-)

 subtest=SubSubTest.new          
 subtest.modify_classvar          #bu metod kendisinde değil ana sınıfta tanımlanmış bir değişkenin(@@classvar) değerini değiştiriyor.
 subtest.print_classvar           #=>kiwi kiwi waaai!! 

Test sınıfının bu altsınıfı aynı zamanda newvar isimli diğer altsınıf içindeki @@classvar değişkenini de değiştirdi. Bu da bize sınıf değişkeninin tüm altsınıflarda ortak kullanıldığını gösteriyor.

 newvar.print_classvar           #=>kiwi kiwi waaai!! 

Mantıksal Ve İşlemi

"and" işlemi verilen iki operandın mantıksal ve işleminin sonucunu verir. "&&" işlemi ile aynı sonucu verir.

Örnek:

a = 1
b = 2
c = nil
puts "tüm argümanlarım true" if a and b
puts "olamaz argümanların biri false" if a and c

Mantıksal Veya İşlemi

"or" işlemi verilen iki operandın mantıksal veya işleminin sonucunu verir. "||" işlemi ile aynı sonucu verir. Örnek:

a = nil
b = "foo"
c = a || b  # c "foo" değerini alır c = (a || b) ile aynı işlemdir.
c = a or b  # c nil değeri alır (c = a) || b ile aynı işlemdir yani sizin tahmin ettiğiniz şey değil.