12
Array
Array (dizim) yapısı hemen her dilde temel bir yapısal veri tipidir ([7, 4]).
Ruby’de array, (dizim), birçok dilde olduğu gibi tamsayılarla damgalanarak (indexed) sıralanan nesneler topluluğudur. Topluluğu oluşturan her
nesneye arrayin bir öğesi denilir. Öğelerin bulunduğu yerler arrayin bileşenleridir. Bileşenleri ana bellekte tamsayılarla indislenmiş sıralı kutular gibi
düşünebiliriz. Kutunun içine konulan nesne, arrayin bir öğesi olur. Arrayin
bileşenleri boş ya da dolu olabilir.
Arrayin ana bellekte tutulduğu yer onun veri ambarı’dır. Kısaca ambar diyeceğiz. Bu durum bir sınıftan yaratılan bütün nesneler için geçerlidir.
Nesne tabanlı programlama dillerinin hepsinde, her sınıf bir veri tipidir, her
veri tipi bir sınıftır. Dolayısyla veri yapısı, ambar ve anlık nesne (instance)
deyimleri eş anlamlıdır. Teknik olarak, hepsi ana bellekte nesnenin tutulduğu yeri ifade eder [6]).
Ruby’de array’in bileşenleri 0’dan başlayıp birer artan tamsayı indislerle (index) sıralanır. Bu durum C ve Java gibi bir çok dilde de böyledir.
Negatif indisler, arrayin sonundan başına doğru göreli bileşenleri belirler.
Örneğin, -1 indisi sonuncu bileşen, -2 indisi sondan ikinci bileşendir. 10 bileşenli bir arrayde -3 indisi, sondan 3-üncü bileşendir. Dolayısıyla, baştan
sayıldığında 6-ıncı bileşene karşılık olur.
12.1
Array Yaratma
Array nesneleri Array sınıfı yardımı ile yaratılır. Bunu yapmak için array
kurucuları, new operatörü ya da Array() metodu kullanılabilir.
BÖLÜM 12. ARRAY
138
12.1.1
Array Kurucuları
[ ] Kurucusu
Ruby’de yeni bir array yaratmak için
Liste 12.1.
[ ](*args)
kurucu fonksiyonu kullanılır. Buna "array literal" deniyor. Array literali,
*args ile belirtilen parametrelerinin sayısına göre farklı arrayler oluşturur.
Liste 12.2, array literali ile array yaratılış örneklerini gösteriyor.
Liste 12.2.
3
[]
[10 ,20 ,30 ,40 ,50 ,60]
[ −5..0 ,..4]
[[1 ,2] ,[3 , ’a ’ ] , [ 4 ] ]
[ x+y , x−y , x∗y ]
#
#
#
#
#
Boş ( n i l ) d i z i m
A l t ı ö ğ e l i tamsayı d i z i m i
Ö ğ l e r i i k i a r a l ı k t a n oluşan dizim
iç içe dizimler
ö ğ e l e r i k e y f i i f a d e l e r d e n oluşan dizim
Açıklamalar: 1.satır boş bir array yaratıyor. Boş arrayin hiç bileşeni yoktur.
Uzunluğu 0’dır.
2.satır altı öğeli bir tamsayı arrayi yaratıyor.
3.satır öğeleri birer aralık (range) olan iki öğeli bir array yaratıyor.
4.satır öğeleri birer array olan üç öğeli bir array yaratıyor.(İç içe array
array).
5.satır öğeleri keyfi ifadelerden oluşan array yaratıyor.
Liste 12.3, array yaratılırken bileşenlerine ilk değerlerin atanışını gösteriyor. Bileşenlerine değerler atanınca array yaratılmış oluyor.
Liste 12.3.
Array . [ ] ( 1 , ’ a ’ , ’A ’ )
Array [ 1 , ’ a ’ , ’A ’ ]
[ 1 , ’ a ’ , ’A ’ ]
Açıklamalar: 1., 2. ve 3. satırlar öğeleri 1, ’a’, ’A’ olan birer array yaratırlar
Arraylere Ad Verme
Liste 12.3 ile yaratılan arraylerin adları (identifier) yoktur. Adları olmayan arrayleri programa çağırmak için, kendilerini yazmak zorundayız. Çok
12.1. ARRAY YARATMA
139
bileşenli arraylerde bu işlem zorluk yaratır. O nedenle, yaratılan her array’e bir ad vermeyi alışkanlık edinmeliyiz. Yukarıdaki örneklere, sırasıyla
dizim1, dizim2, dizim3 adlarını vermek kolaydır:
Liste 12.4.
2
d i z i m 1 = Array . [ ] ( 1 , ’ a ’ , ’A ’ )
d i z i m 2 = Array [ 1 , ’ a ’ , ’A ’ ]
d i z i m 3 = [ 1 , ’ a ’ , ’A ’ ]
Array nesneleri Liste 12.1 ile verilen [ ] array kurucusu tarafından
yaratılır. köşeli parantezlerden oluşan kurucuyu bir fonksiyon olarak düşünürsek, onun parametreleri olur ya da olmaz. Parametrelere göre farklı
arrayler oluştuğunu söylemiştik.
Bazı dillerde arrayin öğeleri aynı veri tipinden oluşur. Ama Ruby’de
arrayin öğeleri farklı veri tiplerinden oluşabilir. Python’daki list yapısı gibidir ([8]).
Aşağıdaki örnek bir tamsayı, bir string ve bir float öğe içeriyor:
Liste 12.5.
d i z i m = [ 1 , " i k i " , 3 . 0 ] # => [ 1 , " i k i " , 3 . 0 ]
12.1.2
Array.new() Kurucusu
Array yaratmanın başka bir yolu, "Array" adının sonuna new operatörünü
eklemektir. Ruby’de her şey nesne olduğuna göre, new de bir nesnedir;
her sınıf için anlık nesne yaratır. Sınıf ile new operatörü arasına nokta (.)
bağlacı konulmalıdır.
Liste 12.6.
4
boş_dizim
= Array . new
nil
= Array . new ( 3 )
false
= Array . new ( 3 , f a l s e )
s ı f ı r _ d i z i m = Array . new ( 3 , 0 )
#
#
#
#
=>
=>
=>
=>
[]
[ nil , nil , nil ]
[ false , false , false ]
[0 , 0 , 0]
Açıklamalar:
1.satır boş bir array yaratır.
2.satır öğeleri nil olan 3 öğeli bir array yaratır.
3.satır öğeleri "false" olan 3 öğeli bir array yaratır.
4.satır öğeleri 0 olan 3 öğeli bir array yaratır
BÖLÜM 12. ARRAY
140
Array yaratırken new operatörünün parametresi olarak 0 ya da istenilen bir tamsayı yazılır. Parametre 0 ise boş (nil) bir array yaratılır.
Paramatre, örneğin 50 ise elli bileşenli bir array yaratılır. Bu arrayin ilk
bileşeninin indisi 0, son bileleninin indisi 49 olur.
Array’in öğelerinin hepsinin belirli bir sabit değere eşit olması isteniyorsa, o sabit değer ikinci parametre olarak yazılır.
Liste 12.6 new operatörünün sıfır, bir ve iki değişkene (argument)
bağlı olması durumlarını gösteriyor. Birincisi boş bir array yaratıyor. İkincisi üç bileşeni olan bir array yaratıyor. Bileşenlere değer atanmadığı için,
her üç bileşenin değeri nil oluyor. Üçüncüde ise üç bileşenli bir array yaratılıyor; kurucunun ikinci değişkeni "false" olduğu için, üç bileşene de "false"
değer atanıyor. Bileşenlere ikinci değişkenin atandığına dikkat ediniz. Tabii,
array değişebilir (mutable) olduğundan, istendiğinde atanan sabit değerler
(örnekte "false") değiştirilebilir. Bazan, bileşenlerin değerleri ileride değişecek arrayleri bu biçimde yaratmak gerekebilir.
12.1.3
String’den Array Yaratma
Ruby bazı özel stringleri beyaz alanlara (boşluk, new line, tab) ayrıştırır;
ayrışan nesnelerden array yaratır. Bu işlemde %w ya da %W operatörleri
kullanılır; küçük w ya da büyük W olması fark yaratmaz.
Liste 12.7.
1
k e l i m e l e r = %w [ Ruby d i l i Python d i l i n e b e n z e r . ]
=> [ " Ruby " , " d i l i " , " Python " , " d i l i n e " , " b e n z e r . " ]
s i m g e l e r = %W( # & < $ ! ? = / )
=> [ "#" , "&" , "<" , " $ " , " ! " , " ? " , "=" , " / " ] $
6
p a r a n t e z l e r = %W| ( ) { } [ ] ’ ’ " " |
=> [ " ( " , " ) " , " { " , " } " , " [ " , " ] " , " ’ " , " ’ " , " \ " " , " \ " " ]
11
b e y a z _ a l a n l a r = %W( \ s \ t \ r \n )
=> [ " " , " \ t " , " \ r " , " \n " ]
Array ( { : a => " a " , : b => " b " } ) # => [ [ : a , " a " ] ,
=> [ [ : a , " a " ] , [ : b , " b " ] ]
[ : b , "b " ] ]
Açıklama:
Üçüncü örnekte, karışıklığı önlemek için, () parantezi yerine | | sınırlayıcısı kullanılmıştır.
12.2. ERIŞIM
12.1.4
141
Farklı veri Tiplerinden Oluşan Array
Ruby’de arrayin bileşenlerine farklı veri tipleri atanabilir. Bunu kuruluş
anında yaparken, bileşenlere atanan değerleri { } blokları içine alarak
ileride doğabilecek karışıklığı önleyebiliriz. Özellikle, bileşenler olarak hash,
string ve başka arrayler atanırken blokları kullanmak yararlı olur.
Liste 12.8.
1
Array . new ( 4 ) { Hash . new } # => [ { } , { } , { } , { } ]
Ayrıca, bu yöntem, çok boyutlu array yaratmanın iyi bir yoludur.
Liste 12.9.
b o ş _ t a b l o = Array . new ( 3 ) { Array . new ( 3 ) }
# => [ [ n i l , n i l , n i l ] , [ n i l , n i l , n i l ] , [ n i l , n i l , n i l ] ]
12.2
Erişim
12.2.1
Array Öğelerine İndisle Erişim
Arrayin bir öğesine erişmek için, onun indisini belirlemek [ ] içinde istenen
öğenin indisini belirlemek yetecektir.
Arrayin bir öğesine erişmek için #[ ] methodu kullanılır. Bu metodun
parametreleri vardır. Parametre tek bir tamsayı ise, o indisli öğe çeğrılır.
Parametre başlangıç ve bitiş indislerini gösteren ikili bir tamsayı çiftinden
de oluşabilir. Negatif indisler, arrayin sonundan başına doğru sayılır.
Liste 12.10.
3
a r r = [ 5 , 2 , −7, 4 0 , ’ a ’ , 6 ]
arr [ 0 ]
# => 5
arr [ 2 ]
# => −7
a r r [ 1 0 0 ] # => n i l
a r r [ −1 ]
# => 6
a r r [ −9 ]
# => n i l
a r r [ −2 ]
# => ’ a ’
Açıklamalar: 1.satır yedi bileşenli arr adlı bir arary yaratıyor. Kuruluş
anında bileşenlere, sırasıyla 5, 2, −7, 40,′ a′ , 6 değerlerini atıyor.
2.satır arr arrayinin, indisi 0 olan ilk öğesini veriyor.
2.satır arr arrayinin, indisi 2 olan bileşeninin değeri olan -7 öğesini
veriyor.
BÖLÜM 12. ARRAY
142
4.satır arr arrayinin indisi 100 olan bir bileşeni olmadığını göstermek
için nil değer veriyor.
5.satır arr arrayinin indisi −1 olan son öğesini veriyor. Eksi indisler,
arrayin sonundan başına doğru göreli öğeyi veriyor.
6.satır arr arrayinin indisi −9 olan bir bileşeni olmadığını göstermek
için nil değer veriyor.
7.satır arr arrayinin, indisi −2 olan bileşeninin değeri olan ’a’ öğesini
veriyor.
12.3
Altarray
Arrayin bir alt arrayine erişmek için, başlangıç ve bitiş indislerini belirlemek
yetecektir.
Liste 12.11.
3
arr = [1 ,2 ,3 ,4 ,5 ,6]
arr [2 , 3]
# => [ 3 , 4 , 5 ]
arr [ 1 . . 4 ]
# => [ 2 , 3 , 4 , 5 ]
a r r [ 1 . . − 3 ] # => [ 2 , 3 , 4 ]
arr . at (0)
# => 1
Açıklamalar:
1.satır arr arrayinin indisi 2 olan öğesinden başlayıp ardışık 3 tane
öğeyi veriyor.
2.satır arr arrayinin indisleri 1 ile 4 arasında olan öğelerini veriyor.
3.satır arr arrayinin indisi baştan 1 ve sondan −3 olan öğeleri arasında
kalanları veriyor.
4.satır arr arrayinin indisi 0 olan öğesini veriyor. Bu yöntem 2.satırdaki yönteme denktir.
slice metodu #[ ] metoduna denktir.
Bazan erişilmek istenen öğenin indisi mevcut indis kümesi içinde olmayabilir. Bu durumu bildiren bir hata iletisinin gelmesi için fetch metodu
kullanılabilir:
Liste 12.12.
arr = [ ’a ’ , ’b ’ , ’ c ’ , ’d ’ , ’ e ’ , ’ f ’ ]
a r r . f e t c h ( 1 0 0 ) # => I n d e x E r r o r : i n d i s 100 a r r a y s ı n ı r l a r ı
−6...6
a r r . f e t c h ( 1 0 0 , " hoop " )
# => " hoop "
dışındadır :
12.3. ALTARRAY
143
first metodu arrayin ilk öğesini, last metodu ise son öğesini verir.
Liste 12.13.
2
a r r . f i r s t # => 1
a r r . l a s t # => 6
Arrayin ilk n öğesini almak için de take metodu kullanılır.
Liste 12.14.
a r r . t a k e ( 3 ) # => [ 1 , 2 , 3 ]
drop metodu take metodunun karşıtıdır. arrayin ilk n öğesini yokeder.
Liste 12.15.
a r r . drop ( 3 ) # => [ 4 , 5 , 6 ]
Liste 12.16 altarray oluşturulmasını gösteriyor.
Liste 12.16.
4
a = ( ’ a ’ . . ’ e ’ ) . to_a # => [ ’ a ’ , ’ b ’ , ’ c ’ , ’ d ’ , ’ e ’ ]
a[0 ,0]
# => [ ] : 0 ö ğ e l i a l t a r r a y
a[1 ,1]
# => [ ’ b ’ ] : b i r ö ğ e l i a l t a r r a y
a [ −2 ,2]
# => [ ’ d ’ , ’ e ’ ] : a r r a y i n son i k i ö ğ e s i
a[0..2]
# => [ ’ a ’ , ’ b ’ , ’ c ’ ] : a r r a y i n i l k üç ö ğ e s i
a [ −2.. −1]
# => [ ’ d ’ , ’ e ’ ] : a r r a y i n son i k i ö ğ e s i
a [0... −1]
# => [ ’ a ’ , ’ b ’ , ’ c ’ , ’ d ’ ] : son öğe h a r i ç
12.3.1
Array Hakkında Bilgi (meta Bilgiler)
length, count, size
Array, kendi uzunluğunu (bileşen sayısını) daima bilir. Bunun için length,
count ve size metotlarını kullanır.
Liste 12.17.
3
b r o w s e r s = [ ’ Chrome ’ , ’ F i r e f o x ’ , ’ S a f a r i ’ , ’ Opera ’ , ’ IE ’ ]
browsers . length
# => 5
b r o w s e r s . count
# => 5
BÖLÜM 12. ARRAY
144
empty?
Arrayin herhangi bir öğe içerip içermediğini anlamak için empty? metodu
kullanılır.
Liste 12.18.
b r o w s e r s . empty ? # => f a l s e
include?
Belirli bir öğeyi içerip içermediğini anlamak için include? metodu kullanılır.
Liste 12.19.
b r o w s e r s . i n c l u d e ? ( ’ Konqueror ’ ) # => f a l s e
12.4
Array Değiştirme
Ruby’de array yapısının değiştirilebilir (mutable) olduğunu söylemiştik. Ancak, bu konuda genel bilgiya sahip olmak gerekir. Array ambarının bileşenleri na bellekte birbirlerini izleyan ardışık hücrelrdir. Array’in bir bileşenine
atanan veri tipini değiştirmek, arrayin boyunu kısaltmak ya da uzatmak gibi
eylemler, array ambarının yapısını bozar. O nedenle, array ambarında yapılacak her değişikliğin, onun farklı bir array ambarına taşınmasını gerektirir.
Ruby, array ambarında yapılan her değişiklik için eski ambarı, gerekiyorsa
yeni array ambarakendiliğinden taşır. Programcıya bir iş bırakmaz. O nedenle, Ruby’de arrayler değişebilir (mutable) deniyor.
Bileşen Adını Değişken Adı Olarak Kullanma
List 12.20’de a arrayinin ilk öğesi değiştiriliyor.
Liste 12.20.
a = [ ’ 06 ’ , 1 , t r u e , −8, 1 2 , −3]
=> [ " 06 " , 1 , t r u e , −8, 1 2 , −3]
4
a [ 0 ] = " Ankara "
=> " Ankara "
a
=> [ " Ankara " , 1 , t r u e , −8, 1 2 , −3]
12.4. ARRAY DEĞIŞTIRME
List 12.21’de a arrayinin indisi 2 olan öğesi değiştiriliyor.
Liste 12.21.
a = [ ’ Ankara ’ , 1 , t r u e , −8, 1 2 , −3]
=> [ " Ankara " , 1 , t r u e , −8, 1 2 , −3]
3
a [2]= f a l s e
=> f a l s e
a
=> [ " Ankara " , 1 , f a l s e , −8, 1 2 , −3]
List 12.22’de a arrayinin son öğesi değiştiriliyor.
Liste 12.22.
a = [ ’ Ankara ’ , 1 , t r u e , −8, 1 2 , −3]
=> [ " Ankara " , 1 , t r u e , −8, 1 2 , −3]
3
a [ −1]= 1 . . 1 0
=> 1 . . 1 0
a
=> [ " Ankara " , 1 , f a l s e , −8, 1 2 , 1 . . 1 0 ]
12.4.1
Arraye Bileşen Ekleme
12.4.2
« Operatörü
« operatörü arrayin sonuna yeni bileşen ekler:
Liste 12.23.
3
ary = [ 0 , 1 , 2 , 3 , 4 ]
a r y << 5
=> [ 0 , 1 , 2 , 3 , 4 , 5 ]
ary
=> [ 0 , 1 , 2 , 3 , 4 , 5 ]
push
push metodu arrayin sonuna yeni bileşen ekler; « ile aynı işi yapar.
Liste 12.24.
arr = [1 , 2 , 3 , 4]
a r r . push ( 5 ) # => [ 1 , 2 , 3 , 4 , 5 ]
a r r << 6
# => [ 1 , 2 , 3 , 4 , 5 , 6 ]
145
BÖLÜM 12. ARRAY
146
unshift
unshift metodu arrayin başına yeni bileşen ekler:
Liste 12.25.
2
arr = [1 , 2 , 3 , 4 , 5 , 6]
a r r . u n s h i f t ( 0 ) # => [ 0 , 1 , 2 , 3 , 4 , 5 , 6 ]
insert
insert metodu arrayin istenilen yerine yeni bileşen ekler (sokuşturma,insertion):
Liste 12.26.
arr . ins er t (3 ,
’ kiraz ’ )
# => [ 0 , 1 , 2 , ’ k i r a z ’ , 3 , 4 , 5 , 6 ]
Liste 12.27.
arr = [0 ,1 ,2 ,3 ,4 ,5 ,6]
a r r . i n s e r t ( 3 , ’ elma ’ , ’ v i ş n e ’ , ’ p o r t a k a l ’ )
# => [ 0 , 1 , 2 , " elma " , " v i ş n e " , " p o r t a k a l " , 3 , 4 , 5 , 6 ]
12.4.3
Bileşen Yoketme
pop Metodu
pop metodu arrayi son öğesini alır ve onu arrayden yokeder.
Liste 12.28.
2
arr = [1 , 2 , 3 , 4 , 5 , 6]
a r r . pop # => 6
a r r # => [ 1 , 2 , 3 , 4 , 5 ]
shift Metodu
shift metodu arrayin ilk öğesini alır ve onu arrayden yokeder.
Liste 12.29.
2
a r r . s h i f t # => 1
a r r # => [ 2 , 3 , 4 , 5 ]
12.4. ARRAY DEĞIŞTIRME
147
delete Metodu
delete metodu array içinde parametrede istenilen değer(ler)i arrayden yokeder ve yokettiklerinin sonuncusunu verir. İstenilen öğe yoksa nil verir.
Liste 12.30.
3
arr = [1 , 2 , 2 , 3]
a r r . d e l e t e ( 2 ) # => 2
a r r # => [ 1 , 3 ]
a = [ "a" , "b" , "b" , "b" , " c " ]
a . delete ( "b" )
# => " b "
a
# => [ " a " , " c " ]
8
a . delete ( "z" )
a . d e l e t e ( " z " ) { " not found " }
# => n i l
# => " not found "
delete_at Metodu
delete_at metodu arrayin istenilen indisli bileşen değerini verir ve o bileşeni
arrayden yokeder. İstenen indisli bileşen yoksa nil verir.
Liste 12.31.
arr = [1 , 2 , 2 , 3]
a r r . d e l e t e _ a t ( 2 ) # => 2
a r r # => [ 1 , 2 , 3 ]
5
a = [ " ar ı " , " kelebek " ,
a . delete_at (2)
# =>
a
# =>
a . delete_at (99)
# =>
" k e d i " , " köpek " ]
" kedi "
[ " a r ı " , " k e l e b e k " , " köpek " ]
nil
delete_if Metodu
delete_if metodu arrayin koşulu sağlayan bütün öğelerini yokeder ve geri
kalan alt arrayi verir.
Liste 12.32.
2
s c o r e s = [ 8 9 , 4 2 , 7 5 , 85 ]
=> [ 8 9 , 4 2 , 7 5 , 85 ]
s c o r e s . d e l e t e _ i f { | s c o r e | s c o r e < 80 }
=> [ 9 7 , 8 5 ]
scores
=> [ 9 7 , 8 5 ]
BÖLÜM 12. ARRAY
148
Liste 12.33.
a r r . d e l e t e _ i f { | a | a < 4 } # => [ 4 , 5 , 6 ]
arr
# => [ 4 , 5 , 6 ]
keep_if
Liste 12.34.
3
arr = [1 , 2 , 3 , 4 , 5 , 6]
a r r . k e e p _ i f { | a | a < 4 } # => [ 1 , 2 , 3 ]
arr
# => [ 1 , 2 , 3 ]
compact Metodu
compact metodu array içinde değeri nil olan bütün bileşenleri yokeder.
Liste 12.35.
2
arr = [ ’ foo ’
a r r . compact
arr
a r r . compact !
arr
, 0 , nil
# => [ ’
# => [ ’
# => [ ’
# => [ ’
, ’ bar ’ ,
foo ’ , 0 ,
foo ’ , 0 ,
foo ’ , 0 ,
foo ’ , 0 ,
7 , ’ basın
’ bar ’ , 7 ,
n i l , ’ bar
’ bar ’ , 7 ,
’ bar ’ , 7 ,
’ , nil ]
’ basın ’ ]
’ , 7 , ’ basın ’ , n i l ]
’ basın ’ ]
’ basın ’ ]
uniq Metodu
uniq metodu array içinde tekrarlayan (duplikasyon) öğelerden birer tane
bırakır; ötekileri yokeder. Bu metot array’in aslını değiştirmez, olduğu gibi
bırakır. O nedenle uniq metoduna bozmayan (non-destructive) yoketme
denilir.
Liste 12.36.
arr = [1 ,1 ,2 ,2 ,3 ,3 ,4 ,4]
a r r . uniq
# => [ 1 , 2 , 3 , 4 ]
arr
# => [ 1 , 1 , 2 , 2 , 3 , 3 , 4 , 4 ]
5
10
harfler = [ "a" , "a" , "b" , "b" , " c " , " c " ]
h a r f l e r . uniq
# => [ " a " , " b " , " c " ]
harfler
# => [ " a " , " a " , " b " , " b " , " c " , " c " ]
arr = [ 2 , 5 , 6 , 556 , 6 , 6 , 8 , 9 , 0 , 123 , 556]
a r r . u n i q # => [ 2 , 5 , 6 , 5 5 6 , 8 , 9 , 0 , 1 2 3 ]
arr
# => [ 2 , 5 , 6 , 5 5 6 , 6 , 6 , 8 , 9 , 0 , 1 2 3 , 5 5 6 ]
12.5. ARRAY ÜZERINDE GEZINME
149
uniq! Metodu
uniq! metodu, uniq metodu gibi, array içinde tekrarlayan (duplikasyon) öğe
içeren bileşenlerden birer tane bırakır; ötekileri yokeder. Ancak, bu metot
array’in aslını değiştirir; aslı yerine yeni biçimini koyar. O nedenle uniq!
metoduna bozguncu (destructive) yoketme denilir.
Liste 12.37.
arr = [1 ,1 ,2 ,2 ,3 ,3 ,4 ,4]
a r r . uniq !
# => [ 1 , 2 , 3 , 4 ]
arr
# => [ 1 , 2 , 3 , 4 ]
4
h a y v a n l a r = Array [ " k e d i " , " köpek " , " köpek " , " köpek " , " f a r e " ]
h a y v a n l a r . u n i q ! # => [ " k e d i " , " köpek " , " f a r e " ]
hayvanlar
# => [ " k e d i " , " köpek " , " f a r e " ]
9
arr = [ 2 , 5 , 6 , 556 , 6 , 6 , 8 , 9 , 0 , 123 , 556]
=> [ 2 , 5 , 6 , 5 5 6 , 6 , 6 , 8 , 9 , 0 , 1 2 3 , 5 5 6 ]
a r r . u n i q ! => [ 2 , 5 , 6 , 5 5 6 , 8 , 9 , 0 , 1 2 3 ]
arr
=> [ 2 , 5 , 6 , 5 5 6 , 8 , 9 , 0 , 1 2 3 ]
12.5
Array Üzerinde Gezinme
each
Enumerable modulünü içeren her sınıfta olduğu gibi, Array sınıfının da each
metodu vardır. Bu metot, array üzerinde gezinirken hangi öğe ne iş yapılacağını belirler. Genellikle, array’in each metodu, array ambarı üzerinde
döngü kurmak için kullanılır
Aşağıdaki örnekte each metodu array üzerinde bir değişiklik yapmaz.
Liste 12.38.
2
3
arr = [1 , 2 , 3 , 4 , 5]
a r r . each { | a | p r i n t a −= 1 0 , " " }
/∗ ∗
Ç ı k t ı : −9 −8 −7 −6 −5
=> [ 1 , 2 , 3 , 4 , 5 ]
∗/
reverse_each
Aşağıdaki örnekte, reverse_each metodu array üzerindeki gezintiyi sondan
başa doğru yapar.
BÖLÜM 12. ARRAY
150
Liste 12.39.
1
# e n c o d i n g u t f −8
6
sa y = %w [ b i r i k i üç d ö r t b e ş a l t ı ]
str = " "
sa y . r e v e r s e _ e a c h { | s a y | s t r += "#{sa y } " }
p s t r # => " a l t ı b e ş d ö r t üç i k i b i r "
map
Array sınıfının map metodu, orijinal arraye dayanarak yeni bir array yaratır. yaratılan arrain öğeleri blok içinde istenildiği gibi değiştirilir. Arraylerin
değişebilir (mutable) sayılması bu nedenledir.
Liste 12.40.
#e n c o d i n g u t f −8
4
arr = [2 ,4 ,6 ,8 ,10]
a r r . map { | a | 2∗ a }
p arr
a r r . map ! { | a | a ∗∗2 }
p arr
12.5.1
#
#
#
#
=>
=>
=>
=>
[2
[2
[4
[4
,
,
,
,
4 , 6 , 8 , 10]
4 , 6 , 8 , 10]
16 , 36 , 64 , 100]
16 , 36 , 64 , 100]
Öğe seçme
Arrayin öğeleri arasından istenenler seçilebilir. Seçilecek öğe ya da öğeler
grubu, blok işlemi olarak belirlenir. Öğeler seçilirken arrayin öğeleri aynen
bırakılabilir ya da değiştirilebilir. Yapılan işleme, sırasıyla bozmayan, nondescructive ya da bozan, descructive seçim denilir.
12.6
Array Sınıfının Başka Metotları
Hemen her dilde olduğu gibi, Ruby’nin Array sınıfı da bileşenlerine erişimi
sağlayan, arama ve sıralama gibi array işlemlerini yapan çok sayıda metoda
sahiptir. Yukarıda açıklananlara ek olarak, çok kullanılan bir kaç metot
daha aşağıdaki örneklerle açıklanmıştır. Array’lere uygulanan metotların
tam liste için Array.methods yazınız ya da [13] web sitesine bakınız.
select
Bozmayan Seçme
12.6. ARRAY SINIFININ BAŞKA METOTLARI
151
select! ve reject! metotları select ve reject metotlarının bozan karşıtlarıdır.
Liste 12.41.
3
arr
arr
arr
arr
arr
= [1 , 2 , 3 , 4 , 5 , 6]
. select { |a| a > 3 }
# => [ 4
. reject { |a| a < 3 }
# => [ 3
. drop_while { | a | a < 4 } # => [ 4
# => [ 1
,
,
,
,
5,
4,
5,
2,
6]
5 , 6]
6]
3 , 4 , 5 , 6]
reject
size
Liste 12.42.
a = [1 , 2 , 3 , 4 , 5]
5
f o r i i n 0 . . ( a . s i z e − 1)
puts a [ i ]
end
each
Liste 12.43.
#e n c o d i n g u t f −8
kHarf = [ " Hey ! " , " kim " , " v a r " , " orada ! " , " s e s v e r " ]
5
10
bHarf = [ ]
kHarf . each do | word |
bHarf << word . u p c a s e
end
p u t s bHarf . i n s p e c t
#=> [ "HEY! " , "KIM" , "VAR" , "ORADA! " , " SES VER" ]
Liste 12.44.
#e n c o d i n g u t f −8
3
sayılar = [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10]
çift_sayılar = []
s a y ı l a r . each do | number |
BÖLÜM 12. ARRAY
152
8
ç i f t _ s a y ı l a r << number i f number%2 == 0
end
p çift_sayılar
# => [ 2 , 4 , 6 , 8 , 1 0 ]
Liste 12.45.
#e n c o d i n g u t f −8
sayılar = [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10]
5
ç i f t _ s a y ı l a r = s a y ı l a r . s e l e c t { | number | number%2 == 0}
p çift_sayılar
# => [ 2 , 4 , 6 , 8 , 1 0 ]
Liste 12.46.
#e n c o d i n g u t f −8
3
sayılar = [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10]
ç i f t _ s a y ı l a r = s a y ı l a r . s e l e c t { | number | number%2 == 0}
p çift_sayılar
# => [ 2 , 4 , 6 , 8 , 1 0 ]
reject1
Liste , Liste 12.47 biçiminde de yapılabilir.
Liste 12.47.
#e n c o d i n g u t f −8
3
sayılar = [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10]
t e k _ s a y ı l a r = s a y ı l a r . r e j e c t { | number | number%2 == 0}
p t e k _ s a y ı l a r # => [ 2 , 4 , 6 , 8 , 1 0 ]
Liste 12.48.
3
a [ 0 , 2 ] = [ ’A ’ , ’B ’ ] # => [ ’A ’ , ’B ’ , ’ c ’ , ’ d ’ ,
a [ 2 . . . 5 ] = [ ’C ’ , ’D ’ , ’E ’ ] # => [ ’A ’ , ’B ’ , ’C ’ ,
a [ 0 , 0 ] = [ 1 , 2 , 3 ] # a ’ n ı n sonuna e k l e
a [0..2] = [] # seçilen öğeleri sil
a [ − 1 , 1 ] = [ ’ Z ’ ] # son ö ğ e y i d e ğ i ş t i r
a [ − 1 , 1 ] = ’ Z ’ # son ö ğ e y i d e ğ i ş t i r
a [ − 2 , 2 ] = n i l # son i k i öğe y e r i n e n i l koy
Liste 12.49.
’e ’]
’D ’ ,
’E ’ ]
12.6. ARRAY SINIFININ BAŞKA METOTLARI
3
153
a = [ 1 , 2 , 3 ] + [ 4 , 5 ] # => [ 1 , 2 , 3 , 4 , 5 ]
a = a + [[6 , 7, 8]]
# => [ 1 , 2 , 3 , 4 , 5 , [ 6 , 7 , 8 ] ]
a = a + 9 # hata : s a ğ yan b i r a r r a y a l m a l ı
Liste 12.50.
2
a
a
a
a
= []
<< 1
<< 2 << 3
<< [ 4 , 5 , 6 ]
#
#
#
#
Boş
=>
=>
=>
array y a r a t ı r
a == [ 1 ]
a == [ 1 , 2 , 3 ]
a == [ 1 , 2 , 3 , [ 4 , 5 , 6 ] ]
Liste 12.51.
1
6
a
b
a
b
a
b
=
=
|
|
&
&
[1 , 1 , 2 , 2 , 3 , 3 , 4]
[5 , 5 , 4 , 4 , 3 , 3 , 2]
b
# => [ 1 , 2 , 3 , 4 , 5 ] : t e k r a r e d e n l e r s i l i n i r
a
# => [ 5 , 4 , 3 , 2 , 1 ] : s ı r a l a m a f a r k l ı
b
# => [ 2 , 3 , 4 ]
a
# => [ 4 , 3 , 2 ]
Liste 12.52.
a = ( ’A ’ . . ’ Z ’ ) . to_a
a . each { | x | p r i n t x }
# => H a r f l e r d e n o l u ş a n a r r a y
# => a l f a b e y i yaz
Liste 12.53.
#e n c o d i n g u t f −8
3
8
2
a r r = %w [ a b 1 8 ] # => a r r == [ ’ a ’ , ’ b ’ , ’ 1 ’ , ’ 8 ’ ]
p arr
p a r a n t e z = %w | ( [ { < | # => p a r a n t e z == [ ’ ( ’ , ’ [ ’ , ’ { ’ , ’ < ’ ]
p parantez
b e y a z l a r = %W( \ s \ t \ r \n ) # => b e y a z l a r == [ " \ s " , " \ t " , " \ r " , " \ n " ]
p beyazlar
/∗ ∗
[ " a " , "b" , "1" , "8"]
[ " ( " , " [ " , " { " , " <"]
[ " " , "\ t " , "\ r " , "\n " ]
∗/
Liste 12.54.
#e n c o d i n g u t f −8
5
10
boş = Array . new
p Array . new
n i l s = Array . new ( 3 )
p nils
s ı f ı r l a r = Array . new ( 4 ,
p sıfırlar
kopya = Array . new ( n i l s )
p kopya
sa y = Array . new ( 3 ) { | i |
p sa y
# => [ ] : boş a r r a y y a r a t ı r
# => n i l s == [ n i l , n i l , n i l ]
0)
# => s ı f ı r l a r == [ 0 , 0 , 0 , 0 ]
# => kopya == n i l s
i +1} # => s a y = = [ 1 , 2 , 3 ]
BÖLÜM 12. ARRAY
154
3
/∗ ∗
[]
[ nil
[0 ,
[ nil
[1 ,
∗/
, nil , nil ]
0 , 0 , 0]
, nil , nil ]
2 , 3]
Liste 12.55.
3
8
a = [0 , 1 , 4 ,
a[0]
#
a [ −1]
#
a [ −2]
#
a [ a . s i z e −1] #
a[−a . s i z e ] #
a[8]
#
a [ −8]
#
9,
=>
=>
=>
=>
=>
=>
=>
1 6 ] # => i n d i s l e r i n k a r e l e r i n d e n oluşam a r r a y
i l k öğe 0 ’ d ı r
son öğe 1 6 ’ d ı r
sondan i k i n c i öğe 9 ’ dur
son öğe
i l k öğe
varolmayan i n d i s , n i l döndürür .
varolmayan i n d i s , n i l döndürür .
Liste 12.56.
#e n c o d i n g u t f −8
2
7
12
17
a = [0 , 1 , 4 , 9 , 16]
p a
a [ 0 ] = " s ı f ı r " # => a == [ " s ı f ı r " , 1 , 4 , 9 , 1 6 ]
p a
a [ − 1 ] = 1 . . 1 6 # => a == [ " s ı f ı r " , 1 , 4 , 9 , 1 . . 1 6 ]
p a
a [ 8 ] = 64 # => a == [ " s ı f ı r " , 1 , 4 , 9 , 1 . . 1 6 , n i l , n i l , n i l , 6 4 ]
p a
a [ − 9 ] = 81 # => E r r o r : can ’ t a s s i g n b e f o r e t h e s t a r t o f an a r r a y
p a
’’’
[0 , 1 , 4 , 9 , 16]
[" sıfır " , 1, 4, 9,
[" sıfır " , 1, 4, 9,
[" sıfır " , 1, 4, 9,
[81 , 1 , 4 , 9 , 1..16
’’’
16]
1..16]
1..16 , nil , nil , nil , 64]
, nil , nil , nil , 64]
Download

Array 12.1 Array Yaratma