15
Döngüler
Belirli bir iş birden çok kez tekrarlanacaksa, programda bu iş bir kez yazılır
ve döngü yapıları o deyim(ler)i istenildiği kadar tekrarlar.
Ruby’de bu işi yapan çok sayıda döngü yapıları vardır. Onlar için eksiksiz bir liste yapmak zordur. Ama öteki dillerde de var olan başlıca döngü
yapılarını açıkladıktan sonra, bu yapıların değişik biçimleri olan ya da bağımsız olan bazı döngülere örnekler verecek ya da alıştırmalarda öğrenciyi
keşfe heveslendireceğiz.
Ruby’nin başlıca döngü yapıları şunlardır: while, until, for.
Bu gruptakilerden birisinin değişik biçimi olan ya da grubun dışında kalan
başka döngü yapıları vardır. Onları örneklerle açıklayacağız.
Döngü Türü
while döngüsü
until döngüsü
for döngüsü
Açıklama
Belirli bir mantıksal deyim true olduğu sürece döngü deyimleri tekrarlanır. Mantıksl deyimin denetimini döngünün başında yapar.
While döngüsünün işlevini yapar; ama mantıksal deyimin
denetimini döngünün sonunda yapar. O nedenle, döndü
deyimleri en az bir kez yürütlür.
Döngü deyimlerinin kaç kez tekrarlanacağını bir sayaç
belirler
Tablo 15.1: Ruby’de Başlıca Döngü Yapıları
184
15.1
BÖLÜM 15. DÖNGÜLER
while döngüsü
Bu döngü yapısı hemen her dilde var olan bir yapıdır. Bir ya da bir grup
deyimin, belli bir koşul sağlandığı sürece tekrarlanması için kullanılan bir
denetim yapısıdır. Sözdizimi şöyledir:
Tanım 15.1.
3
w h i l e ( b o o l e a n ) [ do ]
deyim ( l e r )
end
Deyim sayısı birden çoksa, onları blok parantezi içine almak gerekmez; ama
okunurluğu kolaylaştırmak için do_end içindeki döngü deyimleri { } bloku
içine alınabilir. Bunun nasıl yapılacağı aşağıda yan yana gösterimiştir. Bütün satırlar tek bir satıra yazılmadığı zaman boolean’dan sonra gelen do
sözcüğü konulmayabilir. Ama bütün döngü tek satıra yazıldığında do sözcüğü mutlaka gereklidir.
Liste 15.1.
2
w h i l e ( boolean )
{ deyim1
deyim2
...
deyimN}
end
w h i l e ( b o o l e a n ) do
deyim1
deyim2
...
deyimN
end
boolean (mantıksal deyim) true (doğru) ise deyim ya da blok içindeki deyimler yürütülür. Sonra program akışı başladığı while deyimine döner ve
tekrar boolean mantıksal deyimini denetler. Mantıksal deyim doğru ise deyim ya da blok içindeki deyimler yeniden yürütülür. Bu döngü, mantıksal
deyim false (yanlış) değerini alana kadar yinelenir.
Örnekler:
Program 15.1.
# Yukarıya doğru sayma
x = 0
4
w h i l e x <= 10
puts x
x = x + 1
end
do
15.1. WHILE DÖNGÜSÜ
2
7
185
/∗ ∗
0
1
2
...
10
∗/
7.satır yerine x+ = 1 yazılabilir.
Program 15.2.
# G e r i y e doğru sayma
3
x = 10
8
w h i l e x >= 0
puts x
x = x − 1
end
2
7
do
/∗ ∗
10
9
8
...
0
∗/
7.satır yerine x− = 1 yazılabilir.
Program 15.3.
i = 0
sum = 0
3
w h i l e i < 10 do
i = i + 1
sum = sum + i
end
8
puts "
1
0 . . 9 a r a l ı ğ ı n d a k i s a y ı l a r ı n toplamı :
#{sum} "
/∗ ∗
55
∗/
Program 15.4 while döngüsünde global değişken kullanıyor.
Program 15.4.
186
BÖLÜM 15. DÖNGÜLER
2
$x = 0
$sayaç = 5
7
w h i l e $x < $ s a y a ç do
p u t s ( " Döngünün i = #$x
$x +=1
end
3
/∗ ∗
döngünün
döngünün
döngünün
döngünün
döngünün
∗/
i
i
i
i
i
=
=
=
=
=
0.
1.
2.
3.
4.
adımı " )
adımı
adımı
adımı
adımı
adımı
Daha tıkız yazılış için, while döngüsü tek satıra yazılabilir. Bu durumda [do] anahtarına gerek vardır. Program 15.5 onun yapılışını gösteriyor.
Program 15.5.
# while ; tek s a t ı r
3
x = 0
w h i l e x < 10 do p u t s x = x + 1 end
1
/∗ ∗
1
2
3
...
10
∗/
6
Döngü tek satıra yazıldığında deyim(ler)in do_end bloku içine yazıldığına
dikkat ediniz.
Program 15.6.
3
x = 100
while x > 0
x −= 1
p u t s "Bu döngü #{x} k e z t e k r a r l a r "
end
/∗ ∗
5
#=>
#=>
#=>
#=>
∗/
Bu döngü 99 k e z t e k r a r l a r
Bu döngü 98 k e z t e k r a r l a r
...
Bu döngü 0 k e z t e k r a r l a r
15.1. WHILE DÖNGÜSÜ
187
Program 15.7.
3
i =1
w h i l e i < 11
p r i n t "#{ i } "
i +=1
end
/∗ ∗
1 2 4 5 6 7 8 9 10
∗/
Array Üzerinde While Döngüsü
Her dilde array üzerinde döngü vardır. Ruby’de Program 15.8’deki gibi
yapılır.
Program 15.8.
2
a r r = [ " Can " , " M e l i s " , " P ı n a r " , " Recep " ]
i = 0
7
while arr [ i ]
puts arr [ i ]
i += 1
end
3
/∗ ∗
Can
Melis
Pınar
Recep
∗/
15.1.1
Sonsuz Döngü
Döngü adımlarının bağlı olduğu boolean değer değiştirmezse (true iken
false, false iken true olmazsa), döngü deyimleri sürekli tekrarlanır.Buna
sonsuz döngü denilir. Ruby’nin irb kabuğunda sonsuz döngüyü kesmek için
Ctrl + C tusuna basınız.
Aşağıdaki örneklerde while döngüsünün her adımında boolean ifade
değişmiyor. O nedenle döngü sona ermiyor, döngü adımları durmadan tekrarlanıyor.
Program 15.9.
188
4
BÖLÜM 15. DÖNGÜLER
while 1
p u t s " Merhaba , a d ı n ı z n e d i r ? ( A d ı n ı z ı g i r i n c e Enter ’ e b a s ı n ı z ) "
ad = g e t s . chomp
p u t s "Bu döngüden a s l a ç ı k a m a z s ı n ı z , #{ad } ! ! \ n\n "
end
Burada true koşulu hiç değişmiyor. Dolayısıyla, döngü sona ermez.
Program 15.10.
5
x = 1
while true
puts ( " Giderek sonsuza y a k l a ş ı y o r u z :
x += 1
end
15.2
#{x} " )
until
until döngüsü do-while döngüsüne denk olan bir denetim yapısıdır. until
döngüsü, while döngüsünün işlevini görür. Ancak mantıksal deyim, döngü
deyimlerinden sonra denetlenir. O nedenle, bu yapıda döngü deyimleri en
az bir kez yürütülür. Genel sözdizimi şöyledir:
Liste 15.2.
u n t i l b o o l e a n [ do ]
deyim ( l e r )
end
Program 15.11 , 10’dan başlayıp yukarı doğru 14’e kadar sayıyor.
Program 15.11.
# Yukarıya doğru sayma
2
7
3
x = 10
u n t i l x > 15 do
puts x
x += 1
end
/∗ ∗
10
11
...
14
∗/
Program 15.12, döngünün adımlarını sayıyor.
15.2. UNTIL
189
Program 15.12.
# global değişken
$i = 0
$num = 5
4
u n t i l $ i > $num do
p u t s ( " U n t i l döngüsünün i = #$ i . adımı " )
$ i +=1;
end
2
7
/∗ ∗
Until
Until
Until
Until
Until
Until
∗/
döngüsünün
döngüsünün
döngüsünün
döngüsünün
döngüsünün
döngüsünün
i
i
i
i
i
i
=
=
=
=
=
=
0.
1.
2.
3.
4.
5.
adımı
adımı
adımı
adımı
adımı
adımı
Program 15.13.
# İ l e r i y e doğru sayma
2
x = 0
7
u n t i l x >= 10
puts x
x += 1
end
do
Program 15.14.
2
i =1
u n t i l i > 10
p r i n t "#{ i } "
i +=1
end
/∗ ∗
1 2 4 5 6 7 8 9 10
∗/
Program 15.15.
# e n c o d i n g u t f −8
2
gün_say = 7 ;
7
u n t i l gün_say == 0
p u t s " Şimdi h a f t a n ı n #{gün_say } günü v a r "
gün_say −= 1
end
190
2
7
/∗ ∗
Şimdi
Şimdi
Şimdi
Şimdi
Şimdi
Şimdi
Şimdi
∗/
BÖLÜM 15. DÖNGÜLER
haftanın
haftanın
haftanın
haftanın
haftanın
haftanın
haftanın
7
6
5
4
3
2
1
günü
günü
günü
günü
günü
günü
günü
var
var
var
var
var
var
var
Bu program daha tıkız yazılabilir.
Program 15.16.
1
# e n c o d i n g u t f −8
gün_sayısı = 8
p u t s " Henüz h a f t a d a n k a l a n #{g ü n _ s a y ı s ı −= 1}
g ü n _ s a y ı s ı == 1
1
6
/∗ ∗
Henüz
Henüz
Henüz
Henüz
Henüz
Henüz
Henüz
∗/
haftadan
haftadan
haftadan
haftadan
haftadan
haftadan
haftadan
kalan
kalan
kalan
kalan
kalan
kalan
kalan
7
6
5
4
3
2
1
gün
gün
gün
gün
gün
gün
gün
gün v a r " u n t i l
var
var
var
var
var
var
var
chomp
chomp metodu String’in sonundaki \n, \r ve \r\n karakterlerini yokeder.
Program 15.17’de puts metodunun koyduğu \r\n karakterlerini yokeder.
2.satır, gets ile kullanıcıdan alınan string biçimindeki sayıyı ortaya çıkarır.
Program 15.17.
1
6
p r i n t ’ Bir s a y ı g i r i n i z ’
x = g e t s . chomp . t o _ i
until x < 0
puts x
x −= 1
end
p u t s "Tamam ! "
Program kullanıcıdan bir sayı girmesini istiyor. chomp metodu satırbaşı
karakterini siliyor. Kullanıcının girdiği stringi to_i metodu Integer tipine
dönüştürüyor. Sayısısal olmayan değer girilirse 0 yazar.
1
" abc " . chomp . t o _ i
# => 0
15.2. UNTIL
15.2.1
191
until Döngüsünün Değişik Biçemi
until anahtar sözcüğü, deyimlerin başı yerine begin-end blokunun sonuna
da konulabilir. Genel sözdizimi şöyledir:
Liste 15.3.
begin
deyimler
end u n t i l b o o l e a n
Program 15.16, sayının karesi 25’den büyük olana kadar yukarı doğru
devam ediyor.
Program 15.18.
2
5
x = 0
begin
x += 1
puts x
end u n t i l x ∗∗2 > 25
/∗ ∗
1
2
...
6
∗/
Program 15.11 , 10’dan başlayıp yukarı doğru 14’e kadar sayıyor.
Program 15.19.
# Aşağ ıya doğru sayma
4
2
$ i = 10
$num = 5
begin
p u t s ( " u n t i l s a y a c ı i = #$ i " )
$ i −= 1 ;
end u n t i l $ i < $num
/∗ ∗
10
9
....
5
∗/
192
15.2.2
BÖLÜM 15. DÖNGÜLER
unless döngüsü
unless döngüsü de until döngüsü yerine geçer. Program 15.20 onun nasıl
olduğunu gösteriyor.
Program 15.20.
4
x = 0
begin
x += 1
puts x
end u n l e s s x % 9 == 0
/∗ ∗
∗/
break unless
break anahtar sözcüğü, belirli bir koşul sağlanınca döngüyü sonlandırır.
Program 15.21, 10 dan başlayıp geriye doğru sayarken, 0’a inince
duruyor.
Program 15.21.
2
4
x = 10
l o o p do
puts x
x = x − 1
break u n l e s s x > 0
end
/∗ ∗
10
9
.
.
.
1
∗/
15.2.3
do-while Döngüsü
Kesim 15.2’de Ruby’de öteki dillerde olan do-while yapısının olmadığını söylemiştik. Ama Ruby’de do while döngüsünün işlevini gören ve ona benzeyen
bir yapı kurabiliriz.
15.2. UNTIL
193
Öteki dillerden anımsayacak olursak, do-while döngüsü esas olarak,
while döngüsünün yaptığı işi yapar. Aralarındaki fark, denetlenecek mantıksal deyimin, döngünün sonuna konulmuş olmasıdır. O nedenle, bu yapıda
döngü deyimleri en az bir kez yürütülür.
Ruby’de do-while yapısı için tek bir biçem vermek mümkün değildir1
ama Liste 15.4 yapısını, do-while yapısına en yakın biçem olarak niteleyebiliriz:
Liste 15.4.
2
begin
deyim ( l e r )
end w h i l e b o o l e a n
Program 15.22.
2
a r r = [ " Can " , " M e l i s " , " P ı n a r " , " Recep " ]
i = −1
p u t s a r r [ i += 1 ] w h i l e a r r [ i ]
Program 15.23 oda sıcaklığını her adımda 0.1 celsius derece artırıyor
Program 15.23.
1
6
2
7
# do−w h i l e
celsius_derece = 20.1
begin
p u t s " Şimdi oda s ı c a k l ı ğ ı " + c e l s i u s _ d e r e c e . to_s + " C e l s i u s
derecedir . "
c e l s i u s _ d e r e c e += 0 . 1
end w h i l e c e l s i u s _ d e r e c e < 2 0 . 5
p u t s " Şimdi y e t e r l i s a y ı l a b i l i r . "
/∗ ∗
Şimdi
Şimdi
Şimdi
Şimdi
Şimdi
∗/
oda s ı c a k l ı ğ ı 2 0 . 1 C e l s i u s d e r e c e d i r .
oda s ı c a k l ı ğ ı 2 0 . 2 0 0 0 0 0 0 0 0 0 0 0 0 0 3 C e l s i u s d e r e c e d i r .
oda s ı c a k l ı ğ ı 2 0 . 3 0 0 0 0 0 0 0 0 0 0 0 0 0 4 C e l s i u s d e r e c e d i r .
oda s ı c a k l ı ğ ı 2 0 . 4 0 0 0 0 0 0 0 0 0 0 0 0 0 6 C e l s i u s d e r e c e d i r .
yeterli sayılabilir .
Program 15.24, 3’den başlayıp geriye doğru 1’e kadar sayıyor.
Program 15.24.
1
Ruby’nin genel stratejisini anımsayını: Bir işi yapmanın birden çok yolu vardır. Ruby,
o yolları programcıya daima açık tutar.
194
BÖLÜM 15. DÖNGÜLER
#! / u s r / b i n / ruby
3
3
n = 3
begin
puts n
n −= 1
end w h i l e n > 0
/∗ ∗
3
2
1
∗/
Program 15.25, 1 den başlayıp artan yönde birer birer sayarken, 6 ile
tam bölünebilen ilk sayıya ulaşınca duruyor.
Program 15.25.
5
5
x = 0
begin
x += 1
puts x
end w h i l e x % 6 != 0
/∗ ∗
1
2
...
6
∗/
Daha tıkız yazılış için, döngünün gövdesi tek satırdan oluşturulabilir.
Program 15.26 onun yapılışını gösteriyor.
Program 15.26.
# y u k a r ı y a doğru sayma
x = 0
p u t s x = x + 1 w h i l e x < 10
4
1
6
/∗ ∗
1
2
...
10
∗/
15.3. FOR DÖNGÜSÜ
15.3
for Döngüsü
15.3.1
Aralık (range) İçinde For Döngüsü
195
Ruby’de for döngüsü, sıralı bir veri ambarının öğelerini baştan sona tarayan bir sayaca bağlı deyimlerin tekrarlanmasıyla yapılır. Aslında, Ruby
for döngüsü java dilindeki foreach döngüsü gibidir ([7]. Bu nedenle Ruby
for döngüsü, C ve Pascal’da olduğu gibi, yalnızca bir aritmetik dizi üzerinde kayan sayaca bağlı döngülerden farklıdır. Tabii, Array yapısı her türlü
nesnelerden oluşabildiği için, Ruby for döngüsü daha geneldir. Gerçekten,
array bir aritmetik dizim olarak alınırsa, öteki dillerdeki for döngüleri özel
durum olarak elde edilebilir.
Döngünün kaç kez olacağını biliyorsak, geleneksel olarak for döngüsünü kullanırız.
Program 15.27.
# f o r döngüsü
4
f o r i i n 0 . . 9 do
p r i n t "#{ i } "
end
/∗ ∗
0 1 2 3 ... 9
∗/
Genel olarak, bir aralıktaki öğeleri yazdırmak için aşağıdaki yapıyı
kullanırız:
Program 15.28.
f o r n i n 0 . . 4 do p n end
4
/∗ ∗
1
2
3
4
∗/
Burada p karakteri print metodu yerine geçer.
Program 15.29, 5..7 aralığındaki sayıları 11 ile çarpıyor.
Program 15.29.
196
BÖLÜM 15. DÖNGÜLER
for i in 5..7
p r i n t ( " #{ i } x 11 =
end
2
/∗ ∗
5 x 11 =
6 x 11 =
7 x 11 =
#{ i ∗11}
\n " )
55
66
77
Program 15.30, 0..3 içindeki sayıların herbirisi için aynı stringi yazıyor.
Program 15.30.
1
2
for x in 0..3
p r i n t ( " Sen s e n i b i l s e n s e n i : #{x}
end
/∗ ∗
Sen
Sen
Sen
Sen
∗/
seni
seni
seni
seni
bil
bil
bil
bil
sen
sen
sen
sen
seni
seni
seni
seni
:
:
:
:
\n " )
0
1
2
3
next
next deneticisi bazı dillerdeki continue yerine geçer. Döngü içinde belli bir
deyimi atlayıp, akışı sonraki deyime gönderir.
Program 15.31.
4
4
for i in 0..5
i f i < 2 then
next
end
p u t s " Y e r e l d e ğ i ş k e n i n d e ğ e r i : #{ i } "
end
/∗ ∗
Yerel
Yerel
Yerel
Yerel
∗/
değişkenin
değişkenin
değişkenin
değişkenin
değeri
değeri
değeri
değeri
:
:
:
:
2
3
4
5
Açıklama:
Bu döngüde, i < 2 ise puts metodu çalışmıyor.
puts metodu her argümanı farklı satıra yazar. O nedenle döngülerde,
çıktılar alt alta satırlar biçiminde çıkar. Bazen, yer kazanmak için, çıktıları
yan yana yazmak isteriz. O zaman puts yerine print metodunu kullanmak
sorunu çözecektir.
15.3. FOR DÖNGÜSÜ
197
Örnekler
Program 15.32.
for i in 1..1000
p u t s i i f i % 7==0
end
2
7
/∗ ∗
7
14
21
...
987
994
∗/
Program 15.33, 1..25 aralığındaki sayılara ilk 1000 sayı arasında kaç
tanesinin bölünebildiğini buluyor.
Program 15.33.
2
7
3
8
for y in 1..25
sayaç = 0
for x in 1..1000
s a y a ç += 1 i f x % y == 0
end
p u t s " 1 ’ den 1 0 0 0 ’ e kadar #{y} i l e b ö l ü n e b i l e n
vardır "
end
/∗ ∗
1 ’ den
1 ’ den
1 ’ den
...
1 ’ den
1 ’ den
1 ’ den
∗/
1 0 0 0 ’ e kadar 1 i l e b ö l ü n e b i l e n
1 0 0 0 ’ e kadar 2 i l e b ö l ü n e b i l e n
1 0 0 0 ’ e kadar 3 i l e b ö l ü n e b i l e n
1 0 0 0 ’ e kadar 23 i l e b ö l ü n e b i l e n
1 0 0 0 ’ e kadar 24 i l e b ö l ü n e b i l e n
1 0 0 0 ’ e kadar 25 i l e b ö l ü n e b i l e n
#{s a y a ç } s a y ı
1000 s a y ı v a r d ı r
500 s a y ı v a r d ı r
333 s a y ı v a r d ı r
43 s a y ı v a r d ı r
41 s a y ı v a r d ı r
40 s a y ı v a r d ı r
Program 15.34 içindeki üç döngü birbirlerine denk iş yaparlar.
Program 15.34.
1
6
f o r k i n 1 . . 1 0 do
p u t s " Number #{k} "
end
1 0 . t i m e s do | k |
p u t s " Number #{k+1} "
#
döngü 0 dn b a ş l a r 9 ’ da b i t e r
end
1 . upto ( 1 0 ) { | k | p u t s " Number #{k} " }
198
BÖLÜM 15. DÖNGÜLER
15.3.2
Array üzerinde for döngüsü
Program 15.35.
# e n c o d i n g UTF−8
g e z e g e n l e r = [ " Merkür " , " Venüs " , " Dünya " , " Mars " , " J ü p i t e r " ,
" Satü rn " , " Uranüs " , " Neptün " ]
5
for i in
0 . . . gezegenler . length
puts g e z e g e n l e r [ i ]
end
1
6
/∗ ∗
Merkür
Venüs
Dünya
Mars
Jüpiter
Sa tür n
Uranüs
Neptün
∗/
Program 15.36 bir liste içindeki sayıları topluyor.
Program 15.36.
5
4
arr = [1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10]
toplam = 0
for n in arr
toplam = toplam + n
print
( "#{n} i ç i n Toplam =
end
#{toplam } \n " )
/∗ ∗
1 i ç i n Toplam = 1
2 i ç i n Toplam = 3
3 i ç i n Toplam = 6
...
10 i ç i n Toplam = 55
∗/
Program 15.37 farklı nesnelerden oluşan bir listenin öğelerini yazıyor.
Program 15.37.
3
# a r r a y ü z e r i n d e f o r döngüsü ( l i s t ü z e r i n d e )
a r r = [ " Ankara " , " Elma " , " Otomobil " , 1 , 2 . 0 , t r u e ]
for x in arr
p r i n t ( "#{x}
")
end
15.4. ENUMERATORS
/∗ ∗
Ankara
∗/
Elma
Otomobil
199
1
2.0
true
Program 15.38 str tipi nesnelerden oluşan bir listenin öğelerini yazıyor.
Program 15.38.
2
# a r r a y ü z e r i n d e f o r döngüsü ( l i s t ü z e r i n d e )
a r r = [ ’ Uzun ’ , ’ i n c e ’ , ’ b i r ’ , ’ yoldayım ’ , ’−V e y s e l − ’ ]
for x in arr
p r i n t ( "#{x}
")
end
/∗ ∗
Uzun
∗/
ince
bir
yoldayım
−V e y s e l −
Program 15.39 bir array içindeki sözcüklerin uzunluklarını buluyor.
Program 15.39.
k e l i m e l e r = [ ’ ev ’ , ’ i z m i r ’ , ’ k e d i g i l l e r ’ ]
2
for x in kelimeler
p u t s ( "#{x} ’ i n uzunluğu #{x . l e n g t h } d i r " )
end
5
/∗ ∗
ev ’ i n uzunluğu 2 d i r
i z m i r ’ i n uzunluğu 5 d i r
k e d i g i l l e r ’ i n uzunluğu 10 d i r
∗/
15.4
Enumerators
Enumerator sınıfı veri ambarında gezinme (traverse), arama, sıralama gibi
işleri yapan metotlara sahiptir. Döngüler ile array ve hash koleksiyonlarını bilenler için Enumerable modülünün metotlarının yaptığı işler bilindik
işlerdir. Bu tür koleksyonların each metodu vardır. Enumerator nesnesi,
ambarda gezinirken onun each metodunu çağırır. Böylece, ambardaki her
öğe tek tek ziyaret edilebilir.
each metodu Array sınıfının bir metodudur; ama başka koleksiyonlara
da gezer (iterator) olarak uygulanabilir. Koleksiyondaki ya da bloktaki bütün öğeleri tek tek ziyaret eder.
200
BÖLÜM 15. DÖNGÜLER
Liste 15.5.
e v c i l l e r = [ ’ k e d i ’ , ’ a t ’ , ’ koyun ’ , ’ kuzu ’ ] f o r i i n e v c i l l e r p u t s
e v c i l l e r [ i ] end
ifadesi evciller arrayinin öğelerini verir. Aynı işi yapmak için
Liste 15.6.
e v c i l l e r = [ ’ k e d i ’ , ’ a t ’ , ’ koyun ’ , ’ kuzu ’ ]
i end
e v c i l l e r . each do | i | p u t s
ifadesi tercih edilebilir.
15.5
each |index|
Liste 15.7.
e v c i l l e r = [ ’ k e d i ’ , ’ a t ’ , ’ koyun ’ , ’ kuzu ’ ] . each { | i | p u t s i }
4
/∗ ∗
kedi
at
koyun
kuzu
∗/
Liste 15.8.
a r r a y = [ ’ Superman ’ , ’ Batman ’ , ’ Gariban ’ ]
4
5
a r r a y . each_with_index do | item , i n d e x |
p u t s "#{i n d e x } −> #{item } "
end
/∗ ∗
0 − > Superman
1 − > Batman
2 − > Gariban
∗/
15.6
Sıralama
Klasik sıralama metotlarının hespsi Ruby kodları ile yazılabilir. Onlara ek
olarak, sort_by metodu, enumerator ile numaralanmış koleksiyonları kolayca sıralayabilir.
%w{ a p p l e p e a r f i g } . sort_by { | word | word . l e n g t h }
#=> [ " f i g " , " p e a r " , " a p p l e " ]
Download

Döngüler