Perl Dersleri

PERL"E GİRİŞ
Perl, Unix isletim sistemi için, Larry Wall tarafindan gelistirilmis, yorumlayici bir programlama dilidir. Server tarafinda çalisir. Dosya tipi(uzantisi) "pl" dir. Unix ya da Linux ortaminda; perl programin ilk satirinda;

#!/usr/local/bin/perl yada #!/usr/bin/perl

komut satiri olmalidir. Bu satir, perl derleyicisinin bulundugu dizini belirtir. Dos ortaminda ise ( Perl kodlarinin bulundugu dizinde ); perl dosyaadi.pl diye girilmelidir.

Perl programlarinin çalistirilabilmesi için bir web serverimizin olmasi gerekir. Unix veya Linux ortamlarinda çalisan Apache server veya buna benzeyen programlar kullanilabilir.

Birinci Perl Programı:
Ilk Perl programini deneme yazilimlarla yapicaz denicez ögrenicez. Perl programlama dilinde, ekrana yazdirmak istediklerimizi "print" komutu ile yazdiriyoruz.
Örnek 1:

#!/usr/bin/perl
print ("Birinci Perl Programini yaziyoruz.");

Ekranda söyle görülülecektir:

Birinci Perl Programini yaziyoruz.

Örnek 2:

print ("Adim Soyadim")

Perl "de alt alta yazilar yazmak iiçin "\n" parametresi kullanilir.

Örnek 3:

print ("Alt satira geçmek perl "de\n", " nasil oluyor diye deniyorum.");

Ekranda söyle görülülecektir:

Alt satira geçmek perl "de
nasil oluyor diye deniyorum.

Sayisal Ifadeler:

Perl programlama dilinde; sayisal ifadeler diger dillerde oldugu sekilde yani direct olarak yazilarak ifade edilir. Yani ekrana 15 gibi bir sayisal ifade yazilacaksa bu alttaki sekilde yazilmalidir. :

print (15);

sayisal ifadeler üzerinde yapilan islemler ise C dilinin syntax "ina benzer. Perl, 10"lu sayi sistemi yaninda 8"li ve 16"li sayi sistemlerini de kullanir. Örnegin;

15 sayisinin10"lu sistemde karsiligi: (1*10)+5 = 15
15 sayisinin 8"li sistemde karsiligi: (1*Cool +5 = 13
15 sayisinin 16"li sistemde karsiligi: (1*16)+5 = 21 dir...


PERL"E DERSLERİ - 1
Öncelikle program yazmaya baslamadan önce PERL derleyisini internettan temin etmemiz gerekiyor. Derleyiciyi kullandiginiz isletim sistemi icin asagidaki adreslerden temin edebilirsiniz. Daha genis bilgiyi http://www.Perl.com adresinde bulabilirsiniz.

Atari: ftp://atari.archive.umich.edu/atari/Languages
Apple Macintosh: http://www.Perl.com/CPAN-local/ports/mac
MS-Dos: http://www.Perl.com/CPAN-local/ports/msdos
Novell Netware: http://www.Perl.com/CPAN-local/ports/netware
IBM OS/2: http://www.perl.com/CPAN-local/ports/os2
Windows 95/98: http://www.activeware.com/

Cogunlugun Windows 95/98/NT tabanli bir bilgisayari oldugunu varsayarak, burada Perl derleyicisini bu sistem icin nasil kuracaginizi anlatacagim. Perl derleyicisi, Linux kurulumu sirasinda standart olarak sistem üzerine kurulur. Programi http://www.activeware.com/ adresinden yükledikten sonra Windows Explorer üzerinden secerek calistirin. Bu bir sikistirilmis paket oldugu icin, önce karsiniza söyle bir pencere cikacak:
OK tusuna bastiktan sonra, bir sonraki pencerede sikistirilmis programin hangi kütüge acilacagini tespit edeceksiniz. Programin kurulmasi icin gerekli tüm dosyalar bu kütüge kopyalanacak.
Unzip tusuna bastiktan sonra programi kurmak icin gerekli tüm dosyalar c:\Perl (ya da sizin tespit ettiginiz baska bir kütüge) kopyalanir. Kopyalama islemi sonunda otomatik olarak bu kütükten Perlw32-install.bat programi calismaya baslayarak, PERL derleyicisini sisteminiz üzerinde kurar. Kurma islemi bittikten sonra, bilgisayarinizi kapatarak, yeniden calistirin. Simdi PERL dilinde program yazmaya hazirsiniz. Perl derleyicisini bilgisayariniz üzerinde herhangi bir dizin icinden calistirabilmek icin, autoexec.bat dosyasina asagida yer alan komutu ekleyin:

Set PATH=c:\Perl\bin;$PATH

"Merhaba Dünya" programini yazarak, PERL diline giris yapmak istiyorum.

print "Merhaba Dünya !\n";

Programimiz tek bir satirdan olusuyor ve ekrana Merhaba Dünya yazisini basiyor. Programi nasil calistiracagiz? Herhangi bir editör ile, örnegin Windows notepad, bu satiri yazin ve merhaba.pl ismi altinda bilgisayariniz üzerinde dosyalayin. Simdi MS-DOS promptu acarak asagidaki satiri yazin:

c:\> Perl merhaba.pl

Perl ile derleyiciyi calistiriyor ve argüman olarak program ismini veriyoruz. Derleyici programi derledikten sonra, program sonucunu ekrana basar. Bu durumda ekranda meshur Merhaba Dünya yazisini görecegiz. Eger bilgisayariniz Perl programinin bulamadiysa, command not found seklinde bir mesaj alabilirsiniz. O zaman c:\Perl\bin\Perl merhaba.pl yazarak programi calistiriabilirsiniz.
Program icinde kullandigimiz \n, Merhaba Dünya yazisini ekrana bastiktan sonra yeni bir satira atlar. Print komutu ile bir kelime ya da cümleyi ekrana basmak istiyorsaniz, kelime ya da cümleyi tirnak isaretleri arasina almaniz gerekiyor. Bu rakamlar icin gecerli degildir. Ilerleyen satirlarda bunun örneklerini görecegiz. Bu arada: string terimini sikca kullanacagim icin, simdiden ne anlama geldigini aciklamak istiyorum. String, bir kelime ya da cümleden olusan bir harf gurubudur. Örnegin print "Merhaba Dünya" örneginde print fonksiyonuna, ekrana basmasi icin bir string gönderdik. Stringler, programlama yaparken herzaman kullanacagimiz kaliplar olacaktir. Burada yer alan bircok örnekte de stringler kullanilmaktadir. Bundan böyle kelime ya da cümle yerine string terimini kullanacagim.
Bu kisa giristen sonra, artik isterseniz yavas yavas PERL dilini yakindan inceleyelim.
Bilgisayar programlari bir takim veriler üzerinde calismak icin yazilir. Bu veriler rakam, harf, kelime ya da cümle olabilir. Programlama dillerinde islemek istediginiz verinin hangi tipte oldugunu belirtmeniz gerekmektedir. Veriler, degisken (variable) adi verilen isimler araciligiyla bilgisayar bellegine yerlestirilir.

$isim="Mehmet";
$sayi=1224;

Yukardaki örnekte $isim bir degiskendir ve icerdigi veri "Mehmet" dir. Mehmet bir isim ve kelime oldugu icin, programlama dillerinde bu veritipi string olarak isimlendirilir (daha önce ögrenmistik).
Buna karsi $sayi degiskeni 1224 rakamini icermektedir. $sayi degiskeninin veri tipi ise integer olarak isimlendirilir.
Peki neden veri tiplerine ihtiyacimiz var? Yüksek programlama dilleri olarak bilinen C/C++ ya da Java gibi dillerde kodu derleyen program (Compiler) degiskenlerin veritiplerini siki bir sekilde kontrol eder. Uyusmayan veritipleri arasinda operasyon yapmak mümkün degildir.
Örnegin bir interger degiskeni ile bir string degiskenini toplamak mükün degildir. Eger böyle bir kod yazarsaniz, kodu derleyen Compiler hata vererek, derlemeyi yarida keser. C/C++ ya da Java dillerinde, veritipleri arasindaki uyum kontrol edildigi icin cok komplex programlar yazmak mümkündür. Veritipi uyumu kontrolü sayesinde bilgisayarin bellegi cok iyi organize edilir ve programlar hizli ve hatasiz calisir.
C/C++ ya da Java dillerinde oldugu gibi Perl dilinde de veritipi kontrolü yapilir. Program yazma mantigini anlayabilememiz icin veritiplerini ve nasil kullanildiklarini cok iyi anlamamiz gerekiyor. Bu yüzden: gelin simdi Perl"ün kullandigi veri tiplerini inceleyelim.

Perl de iki veritipi katagorisi vardir:

a. Skalar degiskenler, (sayilar, stringler ve göstergecler)
b. Listeler (array ve hashler)

Skalar olarak isimlendirilen veritipi katagorisi, rakam, harf ya da kelimelerden olusan veriler icin kullanilir.

Skalar Veritipi:

rakam: $sayi=1224;
string: $str="merhaba";

Liste veritipi katagorisinden bir degisken, isminden de anlasildigi gibi, bünyesinde cesitli skalar veri tiplerinden olusan bir listeyi barindirir.

Liste Veritipi:

print (1,2,"AA",4,7); # Listeyi ekrana basar.
print sort (1,5,6,7); # Listeyi kücükten büyüge dogru sirali ekrana basar.
print reverse (3,6,7,2);# Listeyi sondan basa dogru ekrana basar.
($a,$b)=(14,34); # $a ve $b ye parantez icindeki degerleri esler.
$array=(1,2,3); # 1,2,3 rakamlarindan olusan bir liste olusturur.
%HASH=("1","bir",2,"iki"); #Hash tipii bir liste olusturur.

Liste veritipi katagorisine dahil array ve hash degisken tiplerini kitabin ilerleyen sayfalarinda tematize edecegim. Perl dilinde kullanilan veritiplerini tanidik. Veritiplerinin cok önemli olduklarini düsündügüm icin, kitabin ilerleyen sayfalarinda bu konu hakkinda detaya girecegim.
Veritipleri, herhangi bir verinin bilgisayar bellegindeki cinsini belirler. Bilgisayar bellegine yerlestirilen verilere programlama tekniginde degisken olarak tanimlanan isimler araciligla ulasiriz. Örnegin $isim="Ahmet" seklinde bir tanimlama, bilgisayar hafizasinda Ahmet kelimesini alacak kadar bir alan ayarlar. Biz yazdigimiz programin icinden bu veriye $isim degiskeni üzerinde cesitli operasyonlar yaparak ulasiriz.

print $isim; # Ekrana $isim degiskeninin degerini basar.

Degiskenleri, bilgisayar hafizasindaki bölgeleri adresleyen isimler olarak düsünebiliriz. Bu alanlara veriler yerlestirilir. Yerlestirilen verileri bulmak icin degisikenler kullanilir. Perl derleyisi program kodunu derleyebilmek icin, degiskenlerin hangi veritipine sahip oldugunu bilmek zorundadir. Derleyici, veritiplerini kontrol ederek, degiskenler üzerinde yapilacak operasyonlari kararlastirir.
Skalar veritipine sahip degiskenleri daha önce tanidik. Buna göre skalar olan bir degisken rakam, harf ya da kelime cinsinden veri icerebilir:

$sayi=1224; $isim="Mehmet";
print $isim; # Ekrana $isim degiskeninin degerini basar.

PERL"E DERSLERİ - 2
Perl dilinde kullanilan degiskenlerin özelliklerini söyle siralayabiliriz:
" Diger dillerin aksine Perl dilinde degiskenleri kullanmadan önce tanimlamak zorunlulugunuz yok. Degiskeni kullanmak istediginiz yerde tanimlayarak, program icinde kullanabilirsiniz.
" Skalar degiskenlerin hangi veritipine sahip olduklarini belirtmeniz gerekmiyor.
" Degiskenler sayi ya da string cinsinden veri icerebilirler.
" Ayni degiskenin cesitli satirlarda sayi ve string ihtiva etmesi mümkün:

$var=1224;
print $var;
$var="Mehmet";
print $var;

" Eger yapilan operasyon onu gerektiriyorsa, sayi iceren bir degisken stringe ya da bir string sayi tipine cevrilebilir: Eger bir stringin baslangicinda sayi varsa, baslangictan sayinin bitimine kadar string bir rakama cevrilir. Baslangicinda rakam olmayan stringler 0 olarak rakam tipine cevrilir.

$var=" Net Sok. Netyardim Cad.";
$nr=$var + 1;
print $nr; # Ekrana 1225 sayisini basar.

" Degisken kullanirken yapilan en fazla hatalardan birisi, yazim hatalari sonucu birbirinden degisik iki degisken tanimlanmasidir.

$benim_degiskenim=1234;
$benim_degiskeni +=1;
print $benim_degiskenim;

Burada ekrana basilacak sonuc 1234 dür. Istemesekte yazim hatasi oldugu icin $benim_degiskeni ismi altinda ikinci bir degisken yarattik. Yaptigimiz toplama islemi yeni yaratilan degisken üzerinde gecerli oldugu icin, print komutu $benim_degiskenim degiskeninin degeri olan 1234 rakamini ekrana basar. Yazim hatasi sonucu istenmeyen degisken yaratmamak icin program basinda use strict; komutunu kullanabilirsiniz. Use strict, komutundan sonra kullanmak istediginiz her degiskeni my $degiskenim seklinde tanimlamaniz gerekmektedir. Bu sayede yazim hatasi sonucu baska bir isimde degisken yaratmaniz mümkün olmayacaktir.

use strict;
my $var;
$var=13;
$var2=33;
# derleyici, $var2 isminde bir degiskeni my
# kullanarak tanimlamadiginiz icin hata verecektir.
print $var;

Array birden fazla skalar degiskenin yer aldigi bir listedir.

@array=(1,2,3,4,"Mehmet",5,6);
@array2=@array;
@array=(); # Bos bir liste....

Liste elemanlarini cesitli yöntemler kullanarak ekrana basmak mümkündür:

print @array; # 1234Mehmet56
print "@array\n"; # 1 2 3 4 Mehmet 5 6

İsterseniz belirli liste elemanlarini da ekrana basabilirsiniz:

print $array[0]; # Ekrana 1 rakamini basar.

Burada dikkat edilmesi gereken iki husus var: Liste icinde bulunan elemanlar 0 dan baslayan indexle adreslenir. Buna göre listenin ilk elemanini ekrana basmak istiyorsaniz, index numarasi olarak 0 yazmaniz gerekiyor. Listenin tümünü degilde belirli elemanlarini islemek istiyorsak o zaman @ yerine $ kullanmamiz gerekiyor. Daha öncede acikladigim gibi skalar degiskenler icin $ isareti kullanilir. Eger listenin belirli elemanlarina ulasacaksaniz o zaman $ kullanmaniz gerekmektedir, cünkü listenin bir parcasi olan eleman sonucta bir skalar degerdir.

print $array[$#array]; # Ekrana listenin son elemanini basar...

Yukarda kullanilan teknikler disinda döngü kullanarak, liste elemanlarini ekrana basabiliriz:
foreach $elem (@array)
{
print $elem;
}

Döngüleri kitabin ilerdeki bir bölümünde detayli olarak inceleyecegiz.
Bir önceki bölümde listeleri (array) tanidik. Listenin cesitli elemanlari üzerinde operasyon yapabilmek icin bir index numarasiyla bu elamani adreslememiz gerekiyor. Liste elemanlarini 0,1,2,3.... seklinde belirli bir siraya sahiptir.
Perl dilinde cok sik kullanilan ve HASH olarak isimlendirilen özel bir liste tipi vardir. Arraylerin aksine HASH tipi bir listenin elemanlarini adreslemek icin belirli bir sirayi takip etmemiz gerekmiyor. Asagida HASH tipi bir liste görüyorsunuz:

%HASH=(); # Bos die HASH tanimlar.
%HASH_LISTE=("Ahmet" => 24, "Veli" => 30, "Ayse" => 23, "Orhan" => 18 );

HASH tipi listelerde yapilan kayitlar anahtar-deger esleri olarak saklanir.

Anahtar - Deger
---------------------
Ahmet 24
Veli 30
Ayse 23
Orhan 18

Istedigimiz anahtari kullanarak, sahip oldugu degere ulasabliriz.

print $HASH_LISTE{"Mehmet"}; # Ekrana 24 rakamini basar.

Listeye yeni bir anahtar-deger esi eklemek istiyorsaniz:

$HASH_LISTE{"Deniz"}=21;

Burada dikkat edilmesi gereken husus, daha öncede belirttigim gibi $ isaretinin kullanilmasidir. Liste elemanlari skalar cinsten degisken olduklari icin, belirli anahtar-deger üzerinde operasyon yaparken, bu liste elemanlarina $ isareti üzerinden ulasabiliriz.

foreach $anahtar (%HASH_LISTE)
{
print "$anahtar: $HASH_LISTE{"$anahtar"}\n";
}

Yukardaki örnegi uyguladiktan sonra, ekran cikisinda bir düzensizlik tespit edeceksiniz. Array tipi listelerde liste elemanlari, listede yer aldiklari sira numarasina göre isleme konur. HASH tipi listelerde, liste elemanlari belirli bir siraya sahip degildir. Listenin basinda yer alan bir anahtar-deger cifti ekrana listenin sonunda ya da ortasinda yer aliyormuscasina basilabilir. Perl derleyicisi HASH tipi listeleri degisik bir yöntemle hafizaya yerlestirdigi icin, liste icindeki anahtar-deger ciftlerinde belirli bir sira yoktur.

%HASH_LISTE{"Tarkan")=3;
# Hata. Liste elemanlari skalar oldugu icin, elemamanlara
# $ isaretiyle ulasmaniz gerekir.
undef $HASH_LISTE{"Deniz"};
# Deniz anahtarinin degeri 21 silinir.
# Buraya yeni bir deger eklenmedigi sürece, Deniz"indegeri belirsizdir.
delete $HASH_LISTE{"Deniz"};
# anahtar-deger ciftini listeden siler.

Keys operatörünü kullanarak, HASH tipi bir listenin anahtarlarini array tipi bir listede toplayabiliriz:

@anahtarlar=keys %HASH_LISTE;
foreach $elem (@anahtarlar)
{
print $elem;
}

Yukardaki örnek HASH_LISTE sinde bulunan tüm anahtarlari (Ahmet, Veli,Ayse, Orhan) @anahtarlar listesine yerlestirir. Foreach döngüsüyle tüm anahtarlari ekrana basabiliriz. Sort keys operatörü HASH tipi bir listenin anahtarlarini alfabetik siraya göre array tipi bir listeye yerlestirir.

@anahtarlar=sort keys %HASH_LISTE;
foreach $elem (@anahtarlar)
{
print $HASH_LISTE{$elem};
}
foreach $anahtar (sort keys %HASH_LISTE)
{
print $HASH_LISTE{$anahtar};
}

Array ve HASH tipi listeler PERL dilinde sikca kullanilir. Isterseniz simdi bir HASH kullanarak ilk programimizi yazalim. Programimiz klavye üzerinden girilen bir cümle icindeki kelimelerin kac kere kullanildigini sayacak.

# sayac.pl
#######################################
$cuemle=;
chop($cuemle);
@kelimeler=split(/\s/, $cuemle);
foreach $elem (@kelimeler)
{
$HASH{$elem}++;
}
foreach $anahtar (sort keys %HASH)
{
print "$anahtar: $HASH{$anahtar}\n";
}

Program nasil calisiyor?

" ile klavye üzerinden girilen verileri degiskenler kullanarak saklayabilrsiniz. kullanilan bir program, klavye üzerinde herhangi bir string ya da rakam girmenizi bekler. Girilen veri $cuemle degiskenine esitlenir. Programin ilerleyen satirlarinda $cuemle degiskenini kullanarak, klavye üzerinden girilen veriyi isleyebiliriz.
" chop fonksiyonu satir sonunda girilen return (\n) isaretini uzaklastirir.
" @kelimeler=split(/\s/, $cuemle); satiri, girdiginiz cümle icindeki kelimeleri @kelimeler listesine yerlestirir. \s kelimeler arasindaki bos alandir. Split fonksiyonu, cümleyi bosluk alanlarin oldugu yerden kelimelere böler. Buna göre @kelimeler listesinin elemanlari cümle icinde gecen kelimler olacaktir.
" Foreach döngüsünü kullanarak bir HASH yardimiyla her kelimenin kac kere kullanildigini tespit ediyoruz. Cümle icinde gecen her kelime HASH icinde anahtar olarak kullaniliyor. Döngüyü kullanarak her anahtar kelimenin kac kere kullanildigini, bu anahtarin deger kismina yerlestiriyoruz. ($HASH{$elem}++;) ++ operasyonu deger bölümünde bulunan sayiyi bir arttirilacaktir. Buna göre eger bir kelime daha önce kullanilmissa, deger hanesindeki sayi bir arttiracaktir. Eger kelime ilk defa kullaniliyorsa HASH icinde bir anahtar-deger cifti yaratilir ve anahtar hanesine kelime ve deger hanesine 1 konur.

" Sayma islemi bittikten sonra bir döngü yardimiyle anahtar-deger ciftleri ekrana basilir. Tipik bir ekran cikisi söyle olabilir:

Girdigimiz cümle: Bugün hava cok iyi. Bugün kendimi cok iyi hissediyorum.
Ekran cikisi:
Bugün: 2
cok: 2
hava:1
hissediyorum: 1
iyi: 1
iyi. : 1
kendimi: 1


PERL"E DERSLERİ
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=";
chop($cumle);
while ($cumle)
{
print "Klavyeden $cumle girdiniz";
}

Do
{
print "Selam";
$cuemle=;
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++) karekok="sqrt(2);" a="5;" b="10;" c="&topla($a," z="$a+$b;" c="&topla($a," z="$a+$b;" a="5;" b="10;" z="$a+$b;" a="5;" b="10;">" 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, "< satir=")" satir=") {
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=; 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 PERL"E DERSLERİPerl dili öncelikle dosya taramalari yapmak üzere gelistirildi. Bir önceki bölümde dosyalarla nasil calisabilecegimizi ögrendik. Perl"ün yetenekleri bununla sinirli degil. Perl ve diger dillerde regüler terim olarak isimlendirilen harf ve kelime gruplariyla bir metni taramamiz mümkündür. Bu bölümde regüler terimleri inceleyecegiz. Bu terimleri kullanarak, dosyalar üzerinde ne kadar kolay tarama yapabileceginizi göreceksiniz. Regüler terimler dogru kullanildigi taktirde, isimizi kolaylastiracak cok kuvvetli araclardir. Dilerseniz artik regüler terimlerle tanisalim. Regüler terimler, bir dosyanin icinde gecen kelime ve kelime gruplarini bulmak icin kullanilir. Asagidaki örnegi inceleyelim: $var="Bugün hava cok güzel. Arkadaslarla sinemaya gidecegiz."; if($var = ~ /cok/) { print "Cok kelimesi kullaniliyor\n"; } $var degiskeni bir string ihtiva ediyor. If döngüsünü kullanarak, cok kelimesinin string icinde kullanilip, kullanilmadigini kontrol ediyoruz. /cok/ burada kullanilan regüler terimdir. Regüler terimler iki / / isareti arasinda yer alir. Eger aradigimiz regüler terim $var stringi icinde yer aliyorsa, ekranda "Cok kelimesi kullaniliyor" mesajini görecegiz. Bazen icinde aradiginiz regüler terimin bulunmadigi bir dosyayi taramak isteyebilirsiniz. Bu is icin asagidaki örnegi kullanabilirsiniz: NOT (!) operatörünü kullanarak, regüler terimin string icinde bulunmamasi gerektigini belirtiyoruz. If döngüsü, string icinde aradigimiz regüler terimin olmamasi durumunda print komutunu calistiracaktir. $var="Bugün hava cok güzel. Arkadaslarla sinemaya gidecegiz."; if($var !~ /Tiyatro/) { print "Tiyatro kelimesi kullanilmiyor\n"; } Tarama yaparken regüler terime opsiyonlar (flags) verebiliriz. Kullandigimiz opsiyona göre, regüler terimin, tarama sürecinde davranisi degisik olacaktir. Tarama yaparken büyük/kücük harf ayrimi yapmak istemiyorsaniz, i opsinonunu kullanin. $var="Bugün hava cok güzel. Arkadaslarla sinemaya gidecegiz."; if($var= ~/Cok/i) { print "Aradiginiz kelime mevcut.\n"; } Genelde regüler terim taramalari ilk satir üzerinde yapilir. $var degiskeni icindeki string birden fazla satirdan olussaydi, yukarda yer alan programlar, diger satirlarda belki yer alabilecek regüler terimi bulamiyacaklardi. Tüm satirlarda tarama yapmak icin m opsiyonunu kullanabilirsiniz. $var=" Bugün hava cok güzel.\n Arkadaslarla sinemaya gidecegiz.\n Cok güzel bir gün olacak\n"; if($var= ~/cok/im) { print "Aradiginiz kelime mevcut.\n"; } S opsiyonunu kullanarak, satir icinde bulunan regüler terimi baska bir kelimeyle degistirmeniz mümkün. Asagida yer alan örnekte cok kelimesi cok cok kelimeleriyle degistirilecektir. Yeni cümle "Bugün hava cok cok güzel" olacaktir. g (global) opsiyonu ile cümle icinde birden fazla bulunan regüler terimi ayni anda degistirebilirsiniz. g opsiyonunu kullanmadiginiz taktirde bulunan ilk regüler terim degistirilecektir. Diger uyan regüler terimler degistirilmez. $var="Bugün hava cok güzel.\n" if($var= ~/cok/) { $var=~ s/cok/cok cok/g; } print $var; Eger string icinde bulunan bir kelimeyi silmek istiyorsaniz, s opsiyonunu asagida yer aldigi sekilde kullanabilirsiniz. $var="Bugün hava cok güzel.\n"; if($var= ~/cok/) { $var=~ s/cok/ /; } print $var; Daha önceden tanidigimiz i opsiyonunu kullanarak, büyük/kücük yazimi göz ardi edebilirsiniz. Asagidaki örnekte "bugün" kelimesi aranarak, cümle icinden silinmektedir. $var=" Bugün hava cok güzel.\n"; if($var= ~/bugün/i) { $var=~ s/bugün/ /g; } print $var; Kapsamli arama yapmak icin regüler terimlerde özel anlam tasiyan isaretler kullanabiliriz. Bu isaretleri kisaca taniyalim: . : herhangi bir harf/isaret anlamina gelir. [abc] : a, b ya da c. [a-z] : a dan z ye kadar bir kücük harf. [^a-f] : a dan f kadar harf gurubu disindaki herhangi bir kücük harf. \w : harfle baslayan herhangi bir kelime. \W : harfle baslamayan herhangi bir kelime. \s : iki kelime arasindaki bosluk. \d : 0 ila 9 arasinda herhangi bir sayi. ^ : satir baslangici. $ : satir sonu. (abc|de): abc ya da de iceren bir kelime (ikisinden birisi). reg* : reg olarak aranan regüler terimin bir, berden fazla ya da 0 kere kullanilmasi. reg+ : reg olarak aranan regüler terimin bir veya birden fazla kullanilmasi. reg? : reg olarak aranan regüler terimin 0 ya da bir kere kullanilmasi. Belirli bir harfi ya da rakami ariyorsaniz /./ kalibini kullanabilirsiniz. . (nokta) sadece bir harf ya da rakam yerini tutar. if($var=~/./) # En az bir harf/rakamdan olusan kelimeleri bulur. if($var=~/...../) # En az bir 5 harf/rakamdan olusan kelimeleri bulur. if($var=~/[A-Z]../) # Ali, Bil, Kül gibi kelimleri bulur. Büyük bir harfi iki harf/rakam takip eder. if($var=~/[A-Z].[0-9/) # Büyük bir harf ve bir rakam arasinda herhangi bir harf/rakam olan kelimeleri bulur # Ax1, B23, Cy9 kelimelerini bulur. Regüler Terimler - Alternatifler: Alternatifleri kullanarak, tarama sirasinda birden fazla regüler terim kullanabilirsiniz. Listede bulunan terimlerden biri bulunana kadar, tarama islemi sürdürülür. if($var=~/ahmet|mehmet|veli/) { print "OK"; } # $var icinde adi gecen herhangi bir ismi arar. Regüler Terimler - Tekrarlar: Kivantör (quantor) olarak isimlendirilen *, ?, + isaretleri kullanarak, bir kelime icinde arka arkaya kullanilan harf veya rakam gruplarini lokalize edebilirsiniz. * operatörü ile bir harf/rakami 0, 1 yada birden fazla lokalize edebilirsiniz. if($var=~/[A-Z]*/) # Büyük bir harfle baslayan tüm kelimeleri bulur. if($var=~/[a-z]*[0-9]/) # 0, 1 ya da 1 den daha fazla ufak harften sonra bir rakam ihtiva eden tüm kelimeleri bulur. a1, aaaaa3, bbbbb5....... + operatörü ile bir harf/rakami en az 1 yada birden fazla lokalize edebilirsiniz. if($var=~/[A-Z]+\d/) # En az 1 ya da daha fazla büyük harften sonra bir rakam iceren kelimeleri bulur. # A3, B4...... ? operatörü ile bir harf/rakami 0 yada en fazla 1 defa lokalize edebilirsiniz. if($var=~/A?/) # $var icinde ya hic A yok ya da sadece bir tane A var. if($var=~/[A-Z]?/) # $var icinde ya büyük harf yok ya da iki tane büyük harf yan yana degil. Daha önce ekran cikisi yapabilmek icin print() fonksiyonunu kullandik. Program icinde kullanilan degiskenlerin sahip oldugu degerler degisik uzunlukta oldugu ve degiskenlerin degerleri program süresince degistigi icin, ekran cikislarini print() fonksiyonu ile formatlamak zor olacaktir. Printf() fonksiyonunu kullanarak ekran cikisini istediginiz sekilde formatlayabilirsiniz. printf("%d %s %03d\n", 1224, "Merhaba", 1); # Ekran cikisi: "1224 Merhaba 1" printf("(%-20s)\n(%20s)\n", "Merhaba arkadaslar", "Nasilsiniz?"); Printf() fonsiyonu icinde kullanabileceginiz özel isaretler: \a Alarm. \b Backspace. \f Form Feed - Yazici üzerinde yeni bir sayfa. \n Newline - Yeni satir. \r Carriage Return - Yeni satir yapmadan satir basi. \t Yatay Tab - Bir sonraki yatay tabülator pozisyonuna gider. \v Dikey Tab - Bir sonraki dikey tabülator pozisyonuna gider. Perl programlariniza HERE dokümani cercevesinde print() fonksiyonunu kullanmadan text pasajlari ekleyebilirsiniz. Böylece her satir icin print() fonksiyonunu kullanmak zorunda kalmiyacaksiniz. Kitabin CGI bölümünde de görecegimiz gibi, HERE dokümanlari kullanilarak, CGI programlarina HTML sayfa kodlari eklenir. print << var =" <<" var= "Yildiz" semvar="var" araba="(" semaraba="araba" liste="(" semliste="liste" semsub="print" a="5;" a="5;" referans="\$a" var="1224;" ptr="\$var;" liste2="(3,5);" ref="\@liste2;" liste="(1,2,3,$ref,3,5);" hashliste="["> 1, "Iki" => 2, "Üc" =>3 },
{ "One" =>1, "Two" =>2, "Three"=>3 } ]; $ref=\@hashliste;
print $$ref[0]{"Bir"}; # 1
print $$ref[1]{"One"}; # 1

Yazilan uzun programlarda bütün kodun bir dosya icinde yer almasi, kisa sürede kod icinde kaybolmamiza yol acabilir. Programi okunabilir ve düzenli olmasini saglamak icin kod bölümlerini ve subrutinleri baska dosyalar icine koyabiliriz. Require direktifi ile baska dosya icinde bulunan bir kodu kendi programimiza eklememiz mümkün.

################################
# var.pl icinde yer alacak kod
$var=1224;
print $var;
1;
# ana programda require
# direktifinin dogru calisabilmesi
# icin en son satirda 1 olmasi
# gerekiyor.
################################
#Ana programa var.pl dosyasini ekliyoruz
$var=111;
require "var.pl";
print $var; # 1224

Require direktifini kullanarak, programimiza disaridan kod eklememiz mümkündür. Ama Perl eklemek istedigimiz kodu nerede bulacagini nasil biliyor?
Perl derleyicis, @INC listesi icinde bulunan tüm dizinleri, eklemek istediginiz kodu bulmak icin tarar. @INC listesinin icinde yer alan dizinler:

C:\Perl\lib\MSWin32-x86
C:\Perl\lib
C:\Perl\site\5.00502\lib
C:\Perl\site\lib\MSWin32-x86
C:\Perl\site\lib

@INC listesinde yer alan dizinler sistemden sisteme degisir. Asagida yer alan programi calistirarak, sisteminiz üzerindeki Perl dizin semasini ekrana basabilirsiniz.

foreach $elem (@INC)
{
print "$elem\n";
}

Require örneginde gördügümüz gibi, disardan eklenen kodun icinde bulunan tüm degiskenler ana programda yer aldilar. Disardan eklenen kod ana programin bir parcasi olarak görülür. Bu sebepten dolayi ana programda kullandigimiz degiskenler, disardan eklenen kodun da icinde bulunabilecegi icin, zarara ugrayabilirler. Degiskenlerin gecerliliklerini koruduklari bölgeye, kod icinde isim-alani adi verilir. Bu isim-alani icinde degiskenler bellidir. Disaridan ekledigimiz kodun icinde bulunan degiskenler de, kodun icinde diger degiskenlerle ayni isim-alanini paylastiklari icin, ortaya istenmedik durumlar cikabilir. Burada, yabanci kodun, ana program icinde yer alan degiskenlerin isim-alanini kirletmeyecek sekilde, kendi isim alani icinde programa eklenmesi geregi doguyor. Aksi taktirde yabanci kodu satir satir gözden gecirerek, kullanilan degiskenleri kontrol etmemiz gerekiyor. Gözden kacirdigimiz bir degisken, programin gerektigi gibi calismasini engelleyecektir.
Isim-alanlarini birbirinden ayiracak bir mekanizmaya ihtiyacimiz var. Önümüzdeki bölümün konusu ve ayri isim-alanlari olusturmada kullanabilecegimiz paketler olacak.
Paketler yardimiyla isim-alanlarini birbirinden ayirabiliriz. Bir paket nedir ? Dilerseniz önce bu soruyu cevaplayalim.
Bir Paket basli basina bir isim-alani olusturur. Bir paket icinde yer alan tüm degisken ve subrutinler sadece paket icinde, paket ismi olmadan kullanilabilir. Paket disina cikildi zaman, paket ismini kullanarak, paket ismiyle tanimladigimiz isim-alani icindeki degisken ve subrutinlere ulasabiliriz. Böylece paket isimlerini kullanarak, isim-alanlarini birbirinden ayirmis oluyoruz.

Modüller ve Paketler:
Bir paketi, package isim; direktifini kullanarak tanimlayabiliriz. Bu direktiften sonra normal kod yazilir.

package ornek;
$var=1223;
$isim="özcan";
1;

Simdiye kadar herhangi bir paket kullanmadan, Perl programlari yazdik. Ama görmesek de, programlarimizda hep bir paket yer aldi: main. Bütün programlar main paketi ile baslar. Package komutu kullanilarak, paketler arasinda degistirme yapilir.
Simdi require direktifini kullanarak, eklenen kodda bulunan degiskenlerin ana program isim-alanini kirletmeyecek sekilde, ayri isim-alanlari yaratabiliriz.

##########################
# require ile eklenecek kod.
# var.pl
package var;
$sayi=1224;
$main::sayi= 3000;
1;
##########################
# Ana program $
sayi=1500;
require "var.pl";
print "$sayi, \n$var::sayi\n";
##########################


Program hakkinda aciklama yapmadan önce, paket kullanirken dikkat edilmesi gereken hususlara deyinmek istiyorum.
Require direktifi ile programa eklemek istedigimiz paket, isim.pl seklinde dosyalanmalidir. Perl derleyicisi, @INC listesinde bulunan dizinleri tarayarak, paketi iceren .pl dosyasini bulmaya calisir. Genelde paketi iceren dosya, eklendigi ana programin dosyasiyla ayni dizindedir.
Ana programda, requiere "paketismi.pl"; dosyasinin ana programa eklenmesini saglayacaktir.
Yukarda yer alan program nasil calisiyor? Önce ilk bölümdeki kodu var.pl ismi altinda dosyalamaniz gerekiyor. Daha sonra alt kisimda yer alan programi calisitiralim.
Program ekran cikis:

3000
1224

Ana programda $sayi degiskenini tanimladiktan sonra, require direktifi ile var paketini ana programa ekliyoruz. Paket icinde $sayi degiskenini tanimladiktan sonra main::sayi direktifiyle ana programda bulunan $sayi degiskenine 3000 rekamini esliyoruz. Paket icinde yer alan $sayi ve ana programda yer alan $sayi degiskenleri böylece birbirlerinden ayrilmis oluyor. Daha sonra ana programda, ana programin icinde tanimlanmis $sayi ve var paketinde yer alan $var::$sayi rakamlarini ekrana basiyoruz. Paket kullanilarak tanimlanmis isim-alanlarina $paketismi::$degisken seklinde ulasabiliriz.
Yukardaki örnekte görüldügü gibi, paket icinde $main::$sayi=3000; eslemesini yaparak, paket icinden, ana programda bulunan bir degiskeni degistirebiliriz.
Paket kontrüktörü BEGIN direktifi kullanilarak tanimlanir. BEGIN blogu icinde yer alan tüm komutlar pakete görevine baslamadan calistirilir. Paket kontrüktörünü kullarak, paket icinde yer alan degiskenleri belirli bir baslangic degerine esitleyebiliriz.

#################################
package pkg;
BEGIN
{
$var="$var bos degil";
}
&print_var();
sub print_var
{
print $var;
}
#################################
Paket destruktörü END direktifi kullanilarak tanimlanir. END blogu icinde yer alan komutlar program bitiminde calistirilir.
#################################
package pkg;
END
{
$var="$Program sonu geldi.";
}
&print_var();
sub print_var
{
print $var;
}
#################################
Perl modülü bir .pm dosyasi icinde yer alan bir pakettir. Daha önce kullandigimiz paket örnegini modül olacak sekilde degistirelim:
##########################
# use ile eklenecek kod.
# var.pm
package var;
$sayi=1224;
$main::sayi= 3000;
1;
##########################
##########################
# Ana program
$sayi=1500;"
use var;
print "$sayi, \n$var::sayi\n";
##########################

Ana programda use var; yazarak, modülü programimiz icinde kullanabiliriz. Use direktifi, modül icinde bulunan degisken ve subrutinleri ana programin isim-alanina yükler. Perl icin yazilmis modülleri c:\Perl\lib dizininde bulabilirsiniz. Bu modüller .pm ekini tasir ve use direktifi ile ana programa dahil edilirler.

Nesneye Yönelik Programlama:
Nesneye yönelik programlama (OOP, object oriented programming) , C++, Eiffel ve Java diliyle ortaya cikan, yeni bir programlama tarzidir.
OOP, gercek hayatta var olan nesneler örnek alinarak yazilir. Yasadigimiz dünyada hersey bir nesnedir. Her nesnenin bir calisma tarzi ve kendine has disa yönelik davranislari vadir. Bir nesne ile interaksiyona girmek icin, nesnenin icinde ne bulundugunu bilmemize gerek yok. Belirli baglamlar (Interface) üzerinden mesajlar göndererek, nesne ile baglanti kurabiliriz. Nesne bu mesaji alir ve gerekli islemleri yapar.
Perl dilini kullanarak OOP programlar yazmamiz mümkündür. OOP tarzi programlamaya gecmeden, kullanilan bazi terimlere göz atalim.


Sınıflar:
OOP türü yazdigimiz programlarda sadece nesneler vardir. Bu nesneler, mesaj alisverisi yaparak, birbirleriyle haberlesirler.
Nesneler OOP de sinif olarak ifade edilen sablonlardan yaratilir. Her sinif icinde, o siniftan üretilecek nesnelerin özelikleri, davranislari tespit edilir. Örnegin Araba isminde bir sinif yaratabiliriz. Bu siniftan üretilecek nesnelerin ortak yani, bir motor, 4 teker, direksiyon gibi parcalar olacaktir.
Siniflar, nesne üretme yaninda baska bir özellige daha sahiptir. Siniflar arasinda akraba ve is iliskileri kurmak mümkündür. Siniflar hakkinda daha genis bilgiyi, bu bölümün ilerleryen satirlarinda bulacaksiniz.

Nesneler:
OOP de nesneler siniflardan üretilir. Nesneler, siniflarin aksine canlidir ve kimlikleri vardir. Ayni siniftan üretilmis iki nesnenin sahip oldugu degiskenler degisik degerlere sahiptir. Örnegin araba sinifindan üretilen Mercedes ve BMW marka iki arabanin plaka numaralari degisiktir. Burada adi gecen plaka numarasi, sinif icinde yer alan bir özelliktir. Siniftan üretilen her nesne bu özelligi alir. Nesneler üretilirken, nesne özellikleri, sahip olduklari yapiya göre, degisik olacaktir. Araba örneginde oldugu gibi, Mercedes ve BMW nesneleri degisk plaka numaralarina sahiptir.
Yazilan OOP programlarda sadece nesneler ve aralarindaki interaksiyon söz konusudur

Metodlar:
Metodlar bir nesnenin dis dünyaya acilan kapilaridir. Bir nesnenin icinde ne oldugu, nesnenin nasil calistigi disaridan görünmez. Nesnenin sahip oldugu bir ic dünyasi vardir. Eger nesne ile interaksiyona girmek istiyorsak, disa acilan kapilarindan (metodlardan) birini kullanmamiz gerekir. Nesnelere, sinif icinde tanimlanmis ve her nesnenin sahip oldugu metodlar araciligiyla mesaj gönderebiliriz. Eger bir nesneden birsey yapmasini bekliyorsak, metodunu kullanarak, ona bir mesaj göndeririz. Nesne bu mesaji alarak, gerekli islemi yapar.
Metodlar nesnelerin dis dünyaya karsi davranislarini tanimlar. Metodlari, diger programlama dillerinde kullanilan fonksiyonlar olarak düsünebiliriz. Nesneler ile sadece bu metodlari kullanarak, interaksiyona girebiliriz.

Konstruktör:
Nesnelerin siniflardan yapildigini daha önce ögrendik. Nesneler üretilirken, sahip olduklari degiskenlerin degisik degerlerde olmasi gerekir. Araba örneginde oldugu gibi, Mercedes ve BMW marka iki nesnenin degisik plaka numaralarina sahip olmalari gerekir. Bu demek oluyor ki, nesneler üretiliken, onlara degisik kimlikler verecek bir mekanizmaya ihtiyacamiz var.
Bu görevi sinif icinde konstruktörler üstlenir. Nesneler konstruktörler araciligiyla üretilir. Konstruktör bir nesne üretmeden önce, nesne icin gerekli degisken degerleri belirlenir ve bu degerler parametre olarak konstruktöre gönderilir. Kontsruktör bu degerleri kullanarak, nesneyi üretir. Her sinif icinde, nesne üretmek icin bir kontruktör vardir.

Destruktör:
Her sinif icinde kontruktör yaninda birde destruktör bulunur. Destruktörün görevi hayati sona ermis bir nesneyi sistem üzerinden uzaklastirmaktir. Program bitiminde üretilen bütün nesneler destruktör araciligiyla yok edilir.

Miras:
OOP nin en büyük özelliklerinden birisi, siniflar arasindan miras birakma teknigiyle, yazilan kodun, defalarca baska bölümlerde kullanilabilmesidir.
Nesneler siniflardan üretilir. Tasit isminde bir sinifimiz oldugunu düsünün. Bu siniftan motorlu tasitlar ve motorsuz tasirlar isminde iki alt-sinif üretmemiz mümkündür. Bu üretilen iki alt sinif, tasit isimli sinifta olan tüm nesne metod ve degiskenleri miras olarak alirlar. Alt siniflardan bir gram kod eklemeden, nesneler üterebiliriz Alt siniflarda gerekli degisiklikleri yaparak, bu sinifin nesnelerini özellestirebiliriz. Örnegin motorlu tasit sinifina, beygirgücü isminde bir degisken ekleyebilriz. Bu alt siniftan üretilecek bir nesne, tasit isimli sinifta olan tüm metod ve degiskenleri miras olarak aldigi gibi, ayrica beygirgücü isminde yeni bir degiskene daha sahip olacaktir.
Gördügümüz gibi, miras birakma teknigi ile, bir kere yazilan kod, defalarca kullanilabilir. Miras (inheritance) teknigi bunu mümkün kiliyor. Miras birakmanin ve almamini nasil kullanildigini, asagida yer alan örnegimizde görecegiz.
C++ ve Java dillerinde oldugu gibi, Perl dilinde OOP tarzi programlar yazmak mümkündür. Perl dilinde OOP tarzi programlarin nasil yazildigini incelemeden, C++ dilinde bir programi inceleyelim. OOP terimlerini bu örnek üzerinde göstermek istiyorum. Daha sonra bu programin Perl dilinde nasil yazilacagini görecegiz.
Yazacagimiz örnekte Araba isimli bir sinif yer alacak. Miras birakma teknigini kullanarak, Mercedes ve BMW isimlerinde iki alt-sinif üretecegiz. Bu altsiniflara, Araba anasinifinda yer alan tüm metod ve degiskenlerin miras kalmasi yaninda, altsiniflar, kendileri icin gerekli degiskenleri de tanimlayacaklar.
Bu C++ örnegini MS Visual C++ 6.0 programi ile derledim. Programi derlemek icin herhangi bir C++ derleyicini kullanabilirsiniz.

Program asagida yer alan dosyalar icinde yer alacak:
" Araba sinifi deklarasyonu, Araba.h,
" Araba sinifi definisyonu, Araba.cpp
" Mercedes altsinifi deklarasyonu, Mercedes.h,
" Mercedes altsinifi definisyonu, Mercedes.cpp,
" BMW altsinifi deklarasyonu, BMW.h,
" BMW altsinifi definisyonu, BMW.cpp,
" Ana program main.cpp
// Araba.h - Araba sinif deklarasyonu
class Araba
{
public: Araba();
void print();
Araba(char*, int);
~Araba();
protected:
int beygirgucu;
char* plakano;
};

Class direktifi ile bir sinif tanimlanir. Public bölümünde, sinif icinde yer alacak ve sonra üretilen nesneler tarafindan kullanilcak metodlar yer alir. Nesneleri üretmek icin Araba(char*, int) kontruktörü kullanilir. Konsruktöre bir string ve integer parametre olarak gönderilir. Bunun ne anlama geldigini daha sonra görecegiz.
Protected bölümü icinde, nesnelerin sahip olacaklari degiskenler yer alir. Protected ve Private sayesinde, bu degiskenler, disaridan gelebilecek saldirilara karsi korunur. Bu degiskenler sadece sinif metodlari kullanilarak degistirilebilir. OOP de nesnelerin ic hayatlarinin korunmasi önemli bir prensiptir. Hicbir sekilde, nesnenin sahip oldugu degerler disardan degistirilememelidir. Bu islem, metodlar arciligiyla nesneye mesaj gönderilerek yapilabilir. Araba sinifinin beygirgucu ve plakano isminde iki degiskeni vardir. Buna göre, bu siniftan üretilen her nesne yukarda yer alan metod ve degiskenlere sahip olacaktir. Konstruktör kullanilarak, her nesneye baska bir baslangi degeri verilir. Bu sadeye üretilen her nesne baska bilgileri tasir.

// Araba.cpp - Araba sinif definisyonu
#include
#include "Araba.h"
// Konstruktör
Araba::Araba(char* plaka, int ps)
{
plakano=plaka;
beygirgucu=ps;
}
//Destruktör
Araba::~Araba() { }
//Print metodu
void Araba::print()
{
cout<<"Plaka:"<< standart="" dosyasinda="" sinifin="" metodlari="" seklinde="" retecegimiz="" nesnelere="" baslangic="" degerleri="" deklarasyonu="" class="" public="" tanimlamasini="" isminde="" altsinif="" andan="" sinifinin="" m="" zellikleri="" siniflari="" arasinda="" baglanti="" kurabilimek="" icin="" include="" dosyayini="" h="" dosyayina="" arabalari="" n="" aksine="" bu="" c="" marka="" bir="" degiskenleri="" ne="" degiskeninide="" parametre="" z="" nin="" alt="" sifini="" sinifi="" icinde="" plakano="0;" beygirgucu="0;" degiskenlerini="" kolayca="" cpp="" mercedes="" sinif="" definisyonu="" int="" model="" r="" araba="" sinifindan="" aldigimiz="" ve="" redefine="" ettiginiz="" print="" metodu="" void="" cout=""><<"Model:"<
#include "Araba.h"
#include "Mercedes.h"
#include "BMW.h"
void main(void)
{
Mercedes m1("E-200","34-MSB-24",90);
BMW b1("34-FO-060",150);
m1.print();
b1.print();
}

#include direktifi ile, ana- ve altsinif kodlari ana programa eklenir. Mercedes m1("E-200","35-AH-119",90); komutu ile m1 isminde Mercedes sinifindan bir nesne ürettik. Parantez icinde, Mercedes sinifinin kontruktörüne gönderilmek üzere parametreler yer aliyor. Nesnenin sahip oldugu degiskenleri ve degerlerini ekrana basmak icin print() fonksiyonunu kullanacagiz. print() fonksiyonu, Mercedes altsinifina Araba sinifindan miras kalmisti. m1.print(); komutu ile m1 isimli nesneye mesaj göndererek, print() fonksiyonunu calistirmasini söylüyoruz.
Ekran cikisi:

Model: E-200 Plaka: 34-MSB-24 Beygirgucu: 90

Print() metodunu Mercedes altsinifinda degistirdigimiz icin, model degiskeninin degeri de digerlerinin yanida ekrana basilir. Eger Mercedes sinifinda print() isminde bir fonksiyon tanimlamamis olsaydik, nesne, anasinif icinde yer alan print() fonsiyonunu calistiracakti ve ekran cikisi söyle olacakti:

Plaka: 34-MSB-24 Beygirgucu: 90

Ana sinifta yer alan print() fonsiyonunun, Mercedes sinifinda yeralan model degiskeninden haberi olmadigi icin, sadece plakano ve beygirgucu degiskenlerini ekrana basar. Gercektende ana siniflar, altsiniflarinda hangi metodlarin ve degiskenlerin yer aldigini bilmezler. Bunun aksine, alt siniflar, anasinifta yer alan tüm metod ve degiskenleri tanirlar.
OOP yi ve kullanilan terimleri tanidiktan sonra, bu örnegi Perl dilinde yazalim.

#!/usr/bin/Perl
use strict;
print "Content-type: text/html\n\n";
######### Class Araba######
package Araba;
sub araba
{
my $class=shift;
my $this={};
$this->{"plakano"}=shift;
$this->{"beygirgucu"}=shift;
bless($this, $class);
}

Perl"de siniflar paket (package) olarak tanimlanir. C++ örneginde oldugu gibi, sinif isminde bir konstruktör tanimliyoruz. shift, bir subrutine gönderilen parametrelere sirayla ulasabiliriz. Yeni bir nesne üremek icin araba() kontruktörü calistirildiginda, shift üzerinden sirasiyla ulasabilecegimiz bilgiler: sinifismi, plakano ve beygirgücüdür.
Önce shift icinde bulunan ilk bilgi (sinif ismi) $class degiskenine esitlenir. $class degiskeni yardimiyla, üretilecek nesnenin hangi siniftan oldugu tespit edilir. $this, C++ dilinde de kullanilan bir referanstir. Perl de nesnelere referanslar üzerinden ulasilir. Nesnenin sahip oldugu degisken degelerini yerlestirmek icin hash tipi bir liste kullanilir. bless fonksiyonu ile nesne canlanir.

sub print
{
my $this=shift;
print "$this->{"plakano"}\n";
print "$this->{"beygirgucu"}\n";
}

print() subrutini nesne degiskenlerinin degerini ekrana basar. Herhangi bir nesne tarafindan bu metod cagrilidiginda, metoda, shift üzerinden nesne kimligi gönderilir. Bu kimligi $this referansina esitleyerek, subrutin icinde nesne icin gerekli islemleri yapabiliriz.
print "$this->{"plakano"}\n"; ile nesnenin sahip oldugu $plakano isimli degiskenin degeri ekrana basilir. Daha öncede belirttigim gibi, bir nesnenin tüm degisken ve degerleri hash tipi bir listede saklanir. Bu liste araba() konstruktörü tarafindan yaratilir. $this üzerinden nesnenin sahip oldugu tüm degiskenlere ulasabiliriz. ;

sub DESTROY
{
print "Nesnenin hayati son buldu.";
}

Program bitimiyle tüm nesnelerin hayatina son verilir. Nesnenin yasamina son verilmeden önce, DESTROY metodu cagrilir. DESTROY sinif icinde destruktör vazifesi görür.

###### Class Mercedes #######
package Mercedes;
use vars qw(@ISA);
@ISA=qw(Araba);

Perl dilinde altsiniflara miras birakma islemi @ISA listesi üzerinden gerceklesir. @ISA icinde tüm üstsiniflar tanimlanir. Bu konuyu detayli olarak ilerleyen satirlarda inceleyecegiz.

# Kontruktör
sub mercedes
{
my $class=shift;
my $model=shift;
my $plaka=shift;
my $ps=shift;
my $this=Araba->araba($plaka,$ps);
$this->{"model"}=$model;
bless($this, $class);
}
sub print
{
my $this=shift;
print "$this->{"model"}\n";
print "$this->{"plakano"}\n";
print "$this->{"beygirgucu"}\n";
}

Mercedes sinifini Araba sinifinin altsinifi olarak tanimliyoruz. Mercedes @ISA listesin üzerinden bütün Araba metod ve degiskenlerine ulasabilir. Simdi ana programi yazalim:

package main;
my $b1=Mercedes->mercedes("E-200","34-MSB-24",95);
$b1->print();

Ana program yazmak icin main isminde bir paket tanimlamamiz gerekiyor. Daha sonra Mercedes sinifinda yer alan mercedes konstruktörünü kullanarak, $b1 isminde bir nesne olusturuyoruz. $b1 bir referanstir. Bu referansi kullanarak, print() metodunu cagiriyoruz.
Program icinde dikkatinizi cekmis olabilecek birkac noktaya deginmek isiyorum:

* C++ aksine, Perl dilinde konstruktörler derleyici tarafinda otomatik olarak calistirilmaz. C++ dilinde, sinif isminde bir konstruktörün tanimlanmis olmasi gerekir. Perl de böyle bir zorunluluk yok. Konstruktör herhangi bir isimde olabilir. Nesneleri olusturmak icin konstruktörü calistirmaniz gerekir.
* Nesneleri yok etmek icin destruktörü calistirmaniz gerekmez. Bu islemi paketin sahip oldugu destruktör otomatik olarak yapar.
* Bir sinifin metodlarina degisik sekilde parametre girisi yapilir. Örnegin konstruktörler parametre olarak önce sinif ismini alirlar. Normal sinif metodlarina önce nesneye ait $this referansi gönderilir.
* Siniflar arasi miras birakma ve alma @ISA listesi üzerinden gerceklesir. Bu liste icinde tüm ana siniflar yer alir.
* C++ dilinde yer alan public, private, protected koruma mekanizmalari Perl dilinde yoktur.
* Sinif tanimlamak icin kullanilan class gibi özel bir kelime yoktur.
* Metodlar sinif icinde tanimlanir. Sinif icinde kullanilan degiskenlere, hash tipi bir liste üzerinden ulasilabilir. Üretilen her nesnenin, degiskenlerini ve degerlerini sakladigi hash tipi bir listesi vardir.
* Nesneler Perl"de hangi sinifi ait oldugunu bilen referanslardir. Nesne hangi sinifa ait oldugunu bless() fonksiyonu araciligiyla ögrenir. Her konstruktörün en son satirinda bless() fonksiyonu yer alir.