|
PERL'E DERSLERİ -
3
Döngüler bir
degisken ya da liste üzerinde operasyonlari bazi sartlara bagli
olarak birden fazla yapmak icin kullanilir. Döngüler konusunu iyice
anlamadan, karmasik programlar yazmak mümkün olmayacaktir. Daha önce
foreach döngüsüyle tanistik. Bu bölümde döngüler, alternatifler ve
bool operatörleri konularini inceleyecegiz.
Döngüler kullanilirken cesitli sartlar göz önünde bulundurulur.
Kullanilan sartlarin gecersiz ya da mantiksiz olmasi durumunda
kendimizi cabucak sonsuz bir döngü icinde bulabiliriz, bu da
programinizin yapmasi gerekeni yerine getiremiyecegi anlamina gelir.
Döngülerde cogu zaman bool operatörleri olarak isimlendirilen true/false
(dogru/yanlis) , 1/0, AND, OR, NOT kaliplari kullanilir. Bool
operatörleri dogru ya da yanlis verilerini geri verir.
Konuyu derinlemesine incelemeden önce TRUE/FALSE yani dogru ve
yanlisin ne oldugunu inceleyelim.PERL dilinde degiskenler dogru ya
da yanlis olabilir. Asagidaki örneklere bakalim:
Dogru - Yanlis
---------------------------
1 - 0
'Merhaba' - ' '
(1,2,3) - ( )
33 - '0'
Degiskenin sahip oldugu degere göre dogru ya da yanlis oldugunu
tespit edebiliriz. Buna göre degeri belirsiz ya da 0 olan her
degisken yanlisdir. Degeri 1 ya da herhangi tanimlanmis bir veri
olan degisken dogrudur. Dogru ve yanlisin karsiligini 0 ve 1 olarak
tanimlayabiliriz.
Bool operatörlerini yakindan inceleyelim:
AND ( & ): AND operatörünün dogru verisini geri verebilmesi
icin iki degiskeninde dogru olmasi gerekmektedir.
0 & 1 | Sonuc
------------
0 0 | 0
0 1 | 0
1 0 | 0
1 1 | 1
OR ( || ): OR operatörünün dogru verisini geri verebilmesi
icin en az bir degiskenin dogru olmasi gerekmektedir.
1 || 1 | Sonuc
-------------
0 0 | 0
0 1 | 1
1 0 | 1
1 1 | 1
NOT ( ! ): NOT operatörü bir degiskenin degerini tersine
cevirir. Dogru cinsinden bir veriyi yanlis, yanlis cinsinden bir
veriyi dogru yapar.
! | Sonuc
---------
0 | 1
1 | 0
If döngüsü bool operatörlerini kullanarak, if blogu icinde yer alan
komutlari calistirmak icin kullanilir. If blogunun icine girebilmek
icin if sartinin yerine gelmis olmasi gerekmektedir.
$hava_durumu="iyi";
if ($hava_durumu eq "iyi")
{
print "Sinamaya gidiyorum";
}
else
{
print "Evde kaliyorum";
}
Bu örnekte sart olarak $hava_durumu degiskeninin degeri "iyi"
verisiyle karsilastiriliyor. $hava_durumu degiskeninin degeri "iyi"
oldugu icin if blogu icinde yer alan print "Sinamaya gidiyorum";
komutu calistirilir. Eger $hava_durumu baska bir degere sahip
olsaydi else blogunda bulunan print "Evde kaliyourum"; komutu
calistirilacakti. If blogunda bulunan sarti daha kisa yazmaniz
mümkün:
if ($hava_durumu) {....}
$hava_durumu degiskeninin degeri belirli yani "iyi" oldugu icin,
sart dogru olarak nitelendirilir ve if bolgundaki komutlar
calistirilir. Eger $hava_durumu=" "; seklinde bir tanimlama
yapsaydik, if ($hava_durumu) yanlis olarak tabir edilecekti ve else
blogunda bulunan komutlar calistirilacakti. If döngüsünü asagida yer
alan syntax (yazim kurallari) cercevesinde kullanabilirsiniz:
if (sart) {......} else { ......}
if (sart) {......} elsif { ......} else {....}
if (sart) {......} elsif { ......} elsif { ......} else {....}
print "Merhaba" if(sart); #Sart gecerli ise Merhaba ekrana basilir.
Foreach döngüsüyle daha önce tanistik.
# Ekrana 1 den 10 a kadar rakamlari basar
foreach $i (1..10)
{
print $i;
}
# Ekrana HASH tipinde listenin anahtarlarini basar.
foreach $eleman (%HASH)
{
print $eleman;
}
# Ekrana Array tipinde listenin elemanlarini basar.
foreach $eleman (@ARRAY)
{
print $eleman;
}
While döngüsü verilen sart gecerli oldugu sürece blok icindeki
komutlari calistirir.
while($sayi<10) { ...... }
$cumle=<STDIN>;
chop($cumle);
while ($cumle)
{
print "Klavyeden $cumle girdiniz";
}
Do
{
print "Selam";
$cuemle=<STDIN>;
chop($cumle);
}
while ($cumle ne "tamam");
Bu örnekte do döngüsü en az bir kere calisir ve ekranadan klavye
girisi bekler. Blok disinda while komutuyla bir sart belirlenir.
Yukardaki örnekte do icinde girilen kelime "tamam" olmadigi sürece
döngü calismaya devam edecektir. Tamam yazmaniz, döngüden cikmanizi
saglar.
C/C++ ve Java dilinden tanidigimiz for döngüsü Perl dilinde de ayni
syntaxi kullanmaktadir.
for($i=0; $i<10;$i++)
{
print $i;
}
Diger dillerden metod, fonsiyon ya da prosedür olarak tanidigimiz
kod birimleri Perl dilinde subrutin (alt program) olarak
isimlendirilir. Subrutinleri programin herhangi bir yerinde
tanimlayarak, programiniz icinde kullanbilirsiniz. Imprerativ diller
olarak bilinen C ve Pascal gibi dillerde subrutinler programlamada
kullanilan vazgecilemez araclardir. Subrutin yazarak, belirli kod
parcalarini programin istedigimiz yerinde kullanabiliriz. Bu bize
öncelikle kod salatasini engelleme firsati verir. Yazdigimiz kod
düzenli bir yapiya kavusur ve daha da önemlisi bir kere yazdigimiz
kodu programin cesitli yerlerinde subrutinin ismini yazarak
kullanabiliriz.
&ekrana_bas();
.
.
.
sub ekrana_bas
{
print "Bu bir denemedir";
}
Subrutin programin herhangi bir yerine konabilir. Yazdigimiz
subrutini & isaretini kullanarak, program icerisinde
calistirabiliriz. Perl icinde kullanabilecegimiz hazir subrutinler
bulunmaktadir:
$karekok=sqrt(2); print $karekok;
Yukardaki örnekte, sqrt() isimli Perl subrutinini kullanarak, 2
sayisinin karekökünü hesapladik. sqrt subrutini 2 rakaminin
karekökünü hesaplayarak, sonucu $karekoek isimli degiskene esitler.
Burada dikkatimizi ceken bir nokta var: sqrt() subrutininde
parantezler icinde 2 rakamini yazdik. $karekoek degiskeninin degeri
1.414213..... olacaktir. Eger 2 yerine 4 yazmis olsaydik, sonuc 2
olacakti. Bu nasil gerceklesiyor? Bir subrutine parametre girisi
olarak isimlendirilen bu teknigi bundan sonraki bölümde ele alacagim.
Subrutinlere parametre girisi sikca kullanilan ve yazilan kodun cok
dinamik bir sekilde kullanilmasini saglayan bir teknikdir.
Parametre, sqrt() örneginde oldugu gibi subrutine gönderdigimiz
rakamdir. Subrutinlere skalar ve liste cinsinde parametre
gönderebiliriz.
$a=5;
$b=10;
$c=&topla($a, $b);
print $c;
##################
sub topla
{
local($x,$y,$z) = @_;
$z=$a+$b;
}
Program nasil calisiyor?
Önce $a ve $b isimlerinde iki degisken tanimladik. Daha sonra bu
degiskenleri toplama operasyonunu gerceklestirmek icin yazdigimiz
subrutine parametre olarak gönderiyoruz. Burada ilginizi ceken
$c=&topla($a, $b); tanimlamasi olabilir. $c degiskeninin degeri,
toplama icin kullanilan subrutinin geri verdigi degerdir. Subrutin
icinde yer alan en son satirdaki deger, geri verilen degeridir.
Subrutin icindeki en son satir $z=$a+$b; oldugu icin, $z
degiskeninin degeri ana programa geri verilir.
@_ degiskeni Perl derleyicisi tarafindan rezerve edilmis ve
gönderilen parametreleri ihtiva eden liste tipinde bir degiskendir.
Eger bu degeri herhangi bir degiskene esitlersek, subrutine
gönderilen parametreleri, subrutin icinde kullanabiliriz.
Istersek örnegi daha kisa sekilde yazabiliriz:
$a=5;
$b=10;
&topla($a, $b);
#############
sub topla
{
local($x,$y,$z) = @_;
$z=$a+$b;
print $z;
}
Subrutin icinde bulunan en son satirdaki komut print $z; oldugu icin,
&topla(...) sekliden ana programda kullandigimiz subrutin, $a ve $b
degiskenlerinin degerlerini toplayarak sonucu ekrana basar.
Subrutin icinde yer alan en son satir, her zaman geri gömdermek
istedigmiz deger olmayabilir. Örnegin bir döngü kullandiginizda,
geri göndermek istediginiz deger, blok icinde bulunan bir deger
olabilir. return $degisken; komutunu kullanarak, istediginiz bir
degeri subrutin icinden geri gönderebilirsiniz.
$a=5;
$b=10;
&karsilastir($a, $b);
###############
sub karsilastir
{
local($x,$y,$z) = @_;
if ($a<$b)
{
return print $a;
}
else
{
return print $b}
}
Isterseniz subrutin icinde birden fazla degeri geri verebilirsiniz.
Asagidaki örnekte ($saniye, $dakika, $saat) listesi ana programa
geri verilir.
($a, $b, $c)=&zaman();
print "Saat su an: $c:$b:$a\n";
################
sub zaman
{
return ($saniye, $dakika, $saat)=localtime();
}
Perl dilinin en gelismis yetenelerinin basinda dosyalar üzerinde
yapabilecegimiz operasyonlar geliyor. Perl dilinde, bir dosyayi acip,
icerigini ekrana basmak, istedigimiz degisiklikleri yapmak, bazi
kelimeleri taramak bir kac satirlik kodla yapabilecegimiz
islemlerdir.
Bir dosya üzerinde cesitli islemler yapabilmemiz icin, bu dosyayi
acmamiz gerekiyor:
open(ANAHTAR, "< dosya.ismi");
Open fonksiyonunu kullanirken dikkat etmemiz gereken iki nokta var:
ANAHTAR degiskenini bir nevi anahtar olarak düsünebiliriz. Bir dosya
acildiktan sonra ANAHTAR degiskeni icine bu dosya üzerinde operasyon
yapabilmek icin gerekli anahtar yerlestirilir. ANAHTAR yerine
istediginiz bir ismi kullanabilirsiniz. Sistem üzerinde mevcut olan
bir dosyayi okumak icin acmak istiyorsaniz "<" operatörünü
kullanabilirsiniz. Eger yeni bir dosya acmak istiyorsaniz, ">"
kullanabilirsiniz. ">" operatörüyle yeni bir dosya acilir. Eger
sistem üzerinde bu isimde bir dosya varsa, dosya silinir ve
kullanilmak üzere acilir. Bu operatörü kullaniken dikkatli olmaniz
gerekiyor. Istemeden sisteminiz üzerindeki bir dosyayi, bu operatörü
kullanarak silebilirsiniz. Sistem üzerinde bir dosyanin sonuna
ekleme yapmak istiyorsaniz ">>" operatörünü kullanin. ">>" operatörü
istediginiz dosyayi acar ve verileri dosyanin sonuna ekler.
Asagida yer alan program, kendi kodunun bulundugu dosyayi acarak,
kodu ekrana basar.
open(DOSYA, "< dosya.pl");
while($satir=)
{
print $satir;
}
Verdigimiz dosya ismi yanlis ya da dosya sistem üzerinde yok ise,
yukarda yer alan program ekrana hicbirsey basmiyacaktir. En azindan
programin, dosyayi bulamadigina dair bir mesaji ekrana basmasi,
hatayi kisa zamanda bulmamizi sagliyacaktir. Open fonsiyonu, eger
dosyayi acabilirse 1, acamassa 0 geri verir (yani dogru ve yanlis).
Bir if döngüsü kullanarak, open fonksiyonunun basarili olup,
olmadigini ögrenebilir ve ekrana gerekli mesaji basabiliriz.
Asagida yeralan kod bunu yapmaktadir:
if(open(DOSYA, "< dosya.pl"))
{
while($satir=<DOSYA>) {
print $satir;
}
}
else
{
print "Dosya ne yazik ki bulunamadi. Tekrar deneyin\n";
}
Asagida yer alan program, klavyeden dosya ismi alarak, dosyayi acar
ve icerigi ekrana basar:
$isim=<STDIN>; if(open(DOSYA, "< $isim"))
{
while($satir=)
{
print $satir;
}
close(DOSYA);
}
else
{
print "Dosya ne yazik ki bulunamadi. Tekrar deneyin\n";
}
Dosyalar open fonsiyonu ile acildiktan sonra, program sonunda close
komutuyla kapatilmaldir. Isletim sistemi ayni anda sinirli sayida
dosyayi acik tutabilir. Belirli sayida open dan sonra, sistem diger
dosyalari acamaz hale gelebilir. Bunu engellemek ve sistemin düzgün
bir sekilde calismasini saglamak icin close( ) komutunu kullanarak,
actiginiz dosyalari kapatmayi aliskanlik haline getirin
|
