Ruby/Veri Türleri

Vikikitap, özgür kütüphane
Gezinti kısmına atla Arama kısmına atla

Sayısallar[değiştir]

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
0xaabb                    # (Hexadecimal) Fixnum
0377                      # (Octal) Fixnum
-0b1010                   # (Binary [negatif]) Fixnum
0b001_001                 # (Binary) 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)

Karakter Dizileri[değiştir]

Ö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[değiştir]

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)
\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)
\cx control-x
\C-x control-x
\M-x meta-x
\M-\C-x meta-control-x
\x karakter x in kendisi (örneğin \" )

Enterpolasyon[değiştir]

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[değiştir]

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 "çok akıllı" bir dil}
=> "Ruby \"çok akıllı\" bir dil"

Tabii bu Türkçe karakterleri irbde göremiyorsanız $KCODE="UTF8" komutunu kullanın.

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 " veya ' karakterleri escape karakter yapmadan direk 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 matemetik mantığa göre 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 çıkacağını belirler:

Şekil Verici Manası
%q[ ] Enterpolasyon almayan String (\\ \[ ve \] dışında)
%Q[ ] Enterpolasyonlu String (default)
%r[ ] Enterpolasyonlu Regexp (flags can appear after the closing delimiter)
%s[ ] Enterpolasyonsuz Sembol
%w[ ] Enterpolasyonsuz kelime Array, boşlukla ayrılmış
%W[ ] Enterpolasyonlu kelime Array, boşlukla ayrılmış
%x[ ] Enterpolasyonlu shell komutu

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", "üç"]

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

"Here döküman" notasyonu[değiştir]

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

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

Array'ler[değiştir]

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"]
#alan 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 ü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[değiştir]

Hash'ler (sözlükler) temelde arraylere benzerler ama farklı olarak sadece değerler değil , bu değerleri işaret eden anahtarlar (endex 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.

Alanlar[değiştir]

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.

Ranges can only be formed from instances of the same class or subclasses of a common parent, which must be Comparable (implementing <=>).

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 akınız : Range class reference.