Vikikitap

Ruby/Söz Dizimi/Değer İfadeleri

< Ruby | Söz Dizimi

←Değişkenler ve Sabitler | Operatörler→


Sayısallar

düzenle 
123                       # Fixnum
-123                      # Fixnum (işaretli)
1_123                     # Fixnum (altçizgi dikkate alınmaz)
-543                      # Negatif Fixnum
123_456_789_123_456_789   # Bignum
123.45                    # Float
1.2e-3                    # Float
123.45r                   # Kesirli sayı ruby > 2.1 - 2469/20r aynı
0xaabb                    # (Hexadecimal - 16'lı) Fixnum
0377                      # (Octal - 8'li) Fixnum
-0b1010                   # (Binary [negatif] - ikili) Fixnum
0b001_001                 # (Binary - ikili) Fixnum
?a                        # 'a' için ASCII karakter kodu (97)
?\C-a                     # Control-a (1)
?\M-a                     # Meta-a (225)
?\M-\C-a                  # Meta-Control-a (129)


Not: "?a" notasyonu Ruby 1.9 ve sonrasında değişti. 1.9 sonrası ASCII kodu değil karakteri ifade eder, yani ?a == 'a'


Karakter Dizileri

düzenle

Örnekler: 

"bu bir string"
=> "bu bir string"

"üç artı üç eşittir #{3+3}"
=> "üç artı üç eşittir 6" 

foobar = "blah"
"foobar'ın değeri #{foobar}"
=> "foobar'ın değeri blah" 

'foobar\'ın değeri #{foobar}'
=> "foobar'ın değeri #{foobar}"

Bir string tek tırnak ya da çift tırnak ile başlar ve biter. Çift tırnaklı stringler backslash notasyonu ve enterpolasyon için kullanılır. Tek tırnaklı stringler \' ve \\ haricinde kullanılamaz.


Backslash Notasyonu

düzenle

escape karakterleri veya escape dizileri olarak da tanımlanır. Bir string içine özel karakterler eklemek için kullanılır.

Örnek: 

"bu string \niki satırdan oluşur"
"bu stringin içinde \"çift tırnaklar\" var"
Backslash Notasyonu Anlamı
\n yeni satır (0x0a)
\s boşluk (0x20)
\r carriage return (0x0d) — kursör satır başına gider
\t tab (0x09)
\v dikey tab (0x0b)
\f formfeed (0x0c)
\b backspace (0x08)
\a bell/alert (0x07)
\e escape (0x1b)
\nnn oktal değeri nnn olan karakter
\xnn hexadecimal değeri nn olan karakter
\unnnn Unicode karakter U+nnnn (Ruby 1.9 ve sonrası için)
\u{nnnnn} Unicode karakter U+nnnnn , 4 hex dijitten fazlaysa süslü parantez içinde olmalıdır
\cx control-x
\C-x control-x
\M-x meta-x
\M-\C-x meta-control-x
\x karakter x in kendisi (örneğin \" çift tırnak içindeki yazıda çift tırnak varsa kullanılır )


Desimal değeri olan karakterler için şu yapılabilir:

"" << 197 #string'e desimal değeri 197 olan karakteri ekler

=> Å


Enterpolasyon

düzenle

Enterpolasyon ile string içine bir Ruby kodu yazılabilir. Bu kod işleminin sonucu string içine yerleştirilir: 

 "1 + 2 = #{1 + 2}"    #=> "1 + 2 = 3"

 #{işlem}


İşlem herhangi bir Ruby kodu olabilir. Ruby string içi kodlarda çok iyidir. Kod string dışındayken nasıl çalışıyora hataları bile aynı şekil çalışır: 

"hayatın manası = #{1/0}"
=> divided by 0 (ZeroDivisionError)


% Notasyonu

düzenle

Ayrıca bir de Perl'den esinlenen tuhaf bir string ifade yolu vardır: % (yüzde karakteri) ve bir sınırlayıcı kullanarak string ifade edilebilir, örneğin: 

%{Ruby %100 "çok akıllı" bir dil}
=> "Ruby %100 \"çok akıllı\" bir dil"

Tabii bu Türkçe karakterleri irb'de göremiyorsanız $KCODE="UTF8" komutunu kullanın (son sürümler UTF8 default).

Alfanümerik olmayan herhangi bir karakter string sınırlayıcı olarak kullanılabilir. %[bu olabilir], %?ya da bu?, %~ya da bunlar~. Bu string tanımlama şeklini kullandığınızda " (çift tırnak) veya ' (tek tırnak) karakterleri escape karakter yapmadan direkt kullanılabilir, ama tabii ki sizin kullandığınız sınırlayıcının backslash edilmesi gerekir. Ama eğer %(parentez), %[köşeli parantez], %{süslü parantez} veya %<küçük büyük işareti> kullanırsanız bunlar açılıp kapanan şeyler olduğu için backslash kullanmadan birbirlerini karşıladıkları müddetçe kullanılabilir: 

%(string (deyimleri) çok esnektir)
=> "string (deyimleri) çok esnektir"

% işaretinden sonra bir şekil verici karakter kullanılabilir %q[], %Q[], %x[] gibi — bu karakter stringin nasıl işleneceğini ve sonuçta ortaya ne tür bir nesne çıkacağını belirler:

Şekil Verici Manası
%q[ ] Enterpolasyon almayan String ( \\ \[ ve \] dışında ) — tek tırnak benzeri
%Q[ ] Enterpolasyonlu String (default) — çift tırnak benzeri
%r[ ] Enterpolasyonlu Regexp — /.../ yapısı ile aynı ama içinde "/" işareti escape etmeden kullanılabilir (flag'lar sınırlayıcı arkasından konmalıdır)
%i[ ] Boşlukla ayrılmış enterpolasyonsuz sembol Array (Ruby 2.0 sonrası)
%I[ ] Boşlukla ayrılmış enterpolasyonlu sembol Array (Ruby 2.0 sonrası)
%w[ ] Enterpolasyonsuz kelime Array, boşlukla ayrılmış
%W[ ] Enterpolasyonlu kelime Array, boşlukla ayrılmış
%x[ ] Enterpolasyonlu shell komutu
%s[ ] Enterpolasyonsuz Sembol


Burada birkaç örnek: 

%Q{bir\niki\n#{ 1 + 2 }}
=> "bir\niki\n3"

%q{bir\niki\n#{ 1 + 2 }}
=> "bir\\niki\\n#{ 1 + 2 }"

%r{nemo}i
=> /nemo/i

%w{bir iki üç}
=> ["bir", "iki", "üç"]

%i{bir iki üç} # Ruby 2.0 sonrası
=> [:bir, :iki, :üç]

%x{ruby --copyright}
=> "ruby - Copyright (C) 1993-2009 Yukihiro Matsumoto\n"


"Here döküman" notasyonu

düzenle

Bir string yapmanın here document denen bir yolu daha vardır, bunda sınırlayıcılar herhangi bir string olabilir: 

string = <<END
on the one ton temple bell
a moon-moth, folded into sleep,
sits still.
END

Deyim << ile başlar ve hemen arkasından sınırlayıcı gelir. Stringin sonunda sınırlayıcı en son satıra ilk karakterden başlayarak tek başına konur.

Aşağıdaki şekil biraz daha iyi görünümlü olabilir. Burada sonlandırıcı yeni satırın en başında olmak zorunda değildir önünde boşluklarla satırda girinti olabilir: 

string = <<-FIN
           on the one ton temple bell
           a moon-moth, folded into sleep,
           sits still.
         FIN


Alfanümerik olmayan karakterleri sınırlayıcıda kullanmak için çift tırnak içine alınmalıdır: 

string = <<-"."
           orchid breathing
           incense into
           butterfly wings.
         .


Here dökümanları sınırlayıcı etrafına tek tırnak konulmadığı müddetçe enterpolasyon alır.

Öndeki sınırlayıcının arkasından gelen aynı satırdaki şeyler string içine alınmaz, şöyle bir şey yapabilirsiniz: 

strings = [<<END, "short", "strings"]
a long string
END

=> ["a long string\n", "short", "strings"]

Here döküman değeri (burada "a long string\n") başlatıldığı yere konuyor dikkat ederseniz.

Birçok here döküman string birleşebilir: 

string = [<<ONE, <<TWO, <<THREE]
  the first thing
ONE
  the second thing
TWO
  and the third thing
THREE

=> ["  the first thing\n", "  the second thing\n", "  and the third thing\n"]


Hatta metod da kullanabilirsiniz. 

s = <<END.chomp.upcase # Sondaki "\n" çıkarılmış ve büyük harf yapılmış.
abc
END

=> "ABC"


Komut Çalıştırmak

düzenle

Terminal komutlarını ya da harici programları çalıştırıp çıktı almayı , backtick (sola yatık tek tırnak - Türkçe klavyede AltGr+, ile) ile sınırlanan yazılarla yapabilirsiniz. 

# Bulunulan klasörün içindekileri yazar, aynı terminaldeki gibi.
puts `dir`

# Bir domain adının IP adresini bul.
domain = 'ruby-lang.org'
ip = `nslookup #{domain}`.match(/Address: \d+\.\d+\.\d+\.\d+/).to_s 
puts ip
# => Address: 198.49.23.145

# "curl" ile bu web sayfasını indirmek, progress göstermek ve içinden bir örneği bulup yazdırmak.
puts `curl https://en.wikibooks.org/w/index.php?title=Ruby_Programming/Syntax/Literals`.encode('utf-8')
  .match(%r(<h2(?:.(?!</h2>))*Numerics.*?(?=<h2))imsu).to_s    # Bir tek bölüme düşürdük.
  .match(%r((?<=<pre>).*?(?=</pre>))imsu ).to_s                # Bir tek örneğe indirdik.


Kurallı İfadeler

düzenle 
 regex_one = /chapter_\d+/i 
 #=> /chapter_\d+/i
 regex_two = %r(/chapter_\d+)i 
 #=> /\/chapter_\d+/i


Array'ler

düzenle

Bir array negatif olmayan bir tamsayı ile endekslenebilen bir nesne kümesidir. Bir array nesnesini Array.new komutuyla, değerleri köşeli parantez içine virgül ile ayırarak koyarak veya array içinde sadece string nesneler varsa başına %w kodu koyarak boşluklarla ayrılmış olarak tanımlayabilirsiniz 

array_bir   = Array.new
array_iki   = []              # Array.new in kısa bir yolu
array_uc    = ["a", "b", "c"] # array_uc "a", "b" ve "c" nesnelerini içerir
array_dort  = %w'a b c'       # array_dort de "a", "b" ve "c" nesnelerini içerir

array_uc[0]                   # => "a"
array_uc[2]                   # => "c"
array_dort[0]                 # => "a"
#negatif endeksler sondan geri sayılır
array_dort[-2]                # => "b"
#[start, count] endeksleme şeklinde start endeksinden başlayarak count tane nesne getirilir
array_dort[1,2]               # => ["b", "c"]
#aralık kullanımı. Bitiş pozisyonu iki noktada cevaba dahildir, ama üç noktalıda dahil değildir
array_dort[0..1]              # => ["a", "b"]
array_dort[0...1]             # => ["a"]

Son metod, %w kullanmak, aslında String sınıfının split metodunu sadece boşluklarla string parçalamak için kullanılmasının kısayoludur. Aşağıdaki örnekte bahsi geçen iki şekilde string array'ler üretilmiş ve eşitlikleri test edilmiştir. 

array_bir   = %w'elma armut ayva'              # => ["elma", "armut", "ayva"]
array_iki   = 'elma armut ayva'.split          # => ["elma", "armut", "ayva"]
array_bir   == array_iki                       # => true

array_uc    = %w'kedi:köpek:kuş'               # => ["kedi:köpek:kuş"]
array_dort  = 'kedi:köpek:kuş'.split(':')      # => ["kedi", "köpek", "kuş"]
array_uc    == array_dort                      # => false


Hash'ler

düzenle

Hash'ler (sözlükler) temelde arraylere benzerler ama farklı olarak sadece değerler değil , bu değerleri işaret eden anahtarlar (key kelimeleri) da içerir. Her anahtar hash içerisinde sadece bir kez kullanılır. Bir hash nesnesi üretmek için ya Hash.new yazılır ya da süslü parantez içine virgülle ayrılmış anahtar => deger çiftleri ile tanımlanır. 

hash_bir   = Hash.new
hash_iki   = {}         # Hash.new in kısayolu
hash_uc    = {"a" => 1, "b" => 2, "c" => 3} 
#=> {"a"=>1, "b"=>2, "c"=>3}

Genellikle Semboller anahtar olarak kullanılır (hızlı erişim sağlarlar), bu şekilde hash tanımlaması şöyle olur: 

hash_sym   = { :a => 1, :b => 2, :c => 3}   #=> {:b=>2, :c=>3, :a=>1}
hash_sym   = { a: 1, b: 2, c: 3}            #=> {:b=>2, :c=>3, :a=>1}

Ruby 1.9 da 2. sıradaki bu yeni şekil sunuldu.


Hash sıralaması

düzenle

Ruby 1.8'de hash elemanları üzerinde iterasyon "rastgele" bir sıradaydı. Ruby 1.9 ile beraber elemanlar üzerinde iterasyon eklendikleri sırra ile oldu. Ancak bir anahtarı tekrar eklerseniz ya da anahtar değerini değiştirirseniz, iterasyondaki sırası değişmeyecektir. 

>> a = {:a => 1, :b => 2, :c => 3}
#=> {:a=>1, :b=>2, :c=>3}
>> a.keys # iterasyonla anahtarları göster
#=> [:a, :b, :c]
>> a[:b] = 2
>> a.keys
#=> [:a, :b, :c] # aynı sıra
>> a.delete(:b)
>> a[:b] = 4 # tekrar ekle
#=> 4
>> a.keys
#=> [:a, :c, :b] # farklı sıra


Alanlar

düzenle

Bir alan (range) bir veri türünün bir parçasının tüm olası değerlerini ifade eder, daha açıkçası, bir başlangıç ve bir son değeri arasındaki olası tüm değerleri ifade eder.

Şunlar olabilir:

  • 0 ve 5 arasındaki tüm tamsayılar.
  • 0 ve 1 arasındaki tüm sayılar (tamsayı olmayanlar dahil), 1 hariç.
  • 't' ve 'y' arasındaki tüm karakterler.


Ruby'de bu alanlar şöyle tanımlanır: 

0..5
0.0...1.0
't'..'y'

Demek ki alanlar bir başlangıç değeri, bir son değeri ve son değeri kapsayacaksa iki nokta, kapsamayacaksa üç nokta içermektedir.

Bir alan değerler topluluğudur, bir sıralamayı ifade etmez. Bu durumda, 

5..0

dizimi mantıken doğrudur ama sıfır uzunlukta bir alan döner.

alanlar sadece aynı sınıftan oluşumlarla ya da aynı atalara sahip sınıfların oluşumları ile oluşturulabilir , ama karşılaştırılabilir olmalıdırlar (<=> operatörü kullanabilir).

Alanlar Range sınıfının oluşumlarıdır ve metodları vardır. Örneğin bir değerin alan içinde olup olmadığını test için: 

 r = 0..5
 puts r === 4  # => true
 puts r === 7  # => false

Tüm Range metodlarının ayrıntıları için bakınız : Range sınıfı dökümanı ya da class Range.

Önceki: Söz Dizimi/Değişkenler ve Sabitler Index Sonraki: Söz Dizimi/Operatörler
"https://tr.wikibooks.org/w/index.php?title=Ruby/Söz_Dizimi/Değer_İfadeleri&oldid=61861" sayfasından alınmıştır