Perl Dersleri

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