LİSTE ve DİZİLER
 
Listeler:
 
Listeler parantezlerle sınırlandırılmış skalar değerler dizisidir.
 
Ör :   (1, 5.3, "hello", 2)
Bu listenin 4 elemanı vardır. 1 , 5.3 , hello , ve 2. Elemanı olmayan liste boş listedir 
Ör : ()
 
Ör : (17, 26 << 2) listesi 2 elemanlıdır. 17 ve 104.
Ör : (17, $var1 + $var2) Bu örnekte 2 elemanlıdır. 17 ve $var1 ve $var2 toplamı.
 
Aşağıdaki kullanımlar listeler için geçerli diğer örneklerdir.
 
("string", 24.3, " string2")
 
($cevap, "cevap $cevap")
 
Liste elemanlarını Dizilere yerleştirme:
Öncelikle dizilerin tanımını görelim. Dizi değişkeni tanımı için o değişkenin başına @ karakteri konur.
 
Geçerli Adlandırma Örnekleri:
               @my_array
               @list2
               @uzun_isim_de_ kullanılabilir
 
Geçerli olmayan adlandırma Örnekleri:
               @1dizi                   # rakamla başlayamaz
               @_dizi                   # alt-tire ile başlayamaz
               @a.son.dizi           # . kullanılamaz
 
Aşağıdaki örneği inceleyelim
$deger = 1;
@deger = (11, 27.1, "bir string");  
Burada var isimli değişkenler tamamen farklı değişkenlerdir. $var skalar değişken olup,@var ise dizi değişkenidir.
 
Aşağıdaki örnekte, @array bir dizidir ve sırasıyla elemanlarına 1,2,ve 3 atanmıştır.
@array = (1, 2, 3);
 
Dizi elemanlarına erişim:
 
Erişim için o elemanın indisi(numarası) verilir.
 
Ör: $var = @array[0];
burada @array dizisinin 1.elemanının indis'i verilerek(Dizilerde ilk eleman numarası 0 dır) o elemanın değerine ulaşılıyor ve değer
$var değişkenine atanıyor.
 
Dizilerde 
@array[0],  1.elemanı
@array[1],  2.elemanı
@array[2],  3.elemanı
temsil eder ve sıralama bu şekilde devam eder.
 
Örnek:
@array = (1, 2, 3, 4);
 
yukarda @array elemanlarına, liste elemanlarının atanmasını görüyoruz.
 
dizi elemanları şu değerleri taşır:
@array[0],  değeri 1
@array[1],  değeri 2
@array[2],  değeri 3
@array[3],  değeri 4
 
Bu aşamada aşağıdaki atamayı yapalım.
$array[3] = 5;
 
Şimdi dizi elemanları dizilişi şu şekildedir;
 
@array[0],  değeri 1
@array[1],  değeri 2
@array[2],  değeri 3
@array[3],  değeri 5
yani (1, 2, 3, 5).
 
Eğer olmayan dizi elemanı atanmak istenirse  veya negatif (-) değer verilirse atanacağı değişken değeri null stringidir ki 0 a eşittir.
 
Ör:
@array = (1, 2, 3, 4);
$skalar = $array[4]; 
 
dizide 5.eleman yani $array[4] yoktur dolayısıyla $skalar değeri null ("") dir.
benzer şekilde $skalar = $array[-1];  sonucu da aynıdır.
 
Bir de şu örneği inceleyelim.
@array = (1, 2, 3, 4);
$array[6] = 17; 
Dizinin görünümü şu şekildedir,
(1, 2, 3, 4, "", "", 17) 
 
İndis olarak değişken de kullanılır,
Ör:
               $index = 1;
               $skalar = $array[$index];          gibi...
 
Dizi elemanlarına erişimde dizi değişkeninin başında $ olduğuna dikkatinizi çekerim. Çünkü dizinin her bir elemanı skalar değişken olarak işlem görür.
 
Ör:          $sebze[0]  doğru 
               @sebze[0]  ise yanlış kullanımdır.
 
Örnek program: Program adı dizprg.pl olsun
 
#!/usr/local/bin/perl
  @dizi = (1, "tavuk", 1.23, "\"Tamam mi?\"", 9.33e+23);
  $say = 1;
  while ($count <= 5) {
          print ("$say . eleman @dizi[$say-1]\n");
          $say++;
  }
 
Çalısması :
>dizprg.pl
    1 . eleman 1 
    2 . eleman tavuk
    3 . eleman 1.23
    4 . eleman  "Tamam mi?"
    5 . eleman   9.3300000000000005+e23
>
 
Örnek program: program adı randiz.pl
# rand() fonksiyonu ile 1- 10 arası random sayı üreten program
#!/usr/local/bin/perl
  $say = 1;
  while ($say <= 100) {
         $randnum = int( rand(10) ) + 1;
         $randtoplam[$randnum] += 1;
         $say++;
  }
# Herbir sayı için toplamı yaz
 $say = 1;
 print ("Herbir sayı için toplam:\n");
 while ($say <= 10) {
         print ("\tsayi $say: $randtoplam[$say]\n");
        $say++;
 }
 
Çalısması:
>randiz.pl
Herbir sayı için toplam:
            sayi 1: 11
            sayi 2: 8
            sayi 3: 13
            sayi 4: 6
            sayi 5: 10
            sayi 6: 9
            sayi 7: 12
            sayi 8: 11
            sayi 9: 11
            sayi 10: 9
>
 
LİSTE gösterimi:
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) gösterimi ile (1..10) gösterimi aynıdır.
(2, 5..7, 11) örneğinden anlaşılan ise şudur:
listenin 5 elemanı vardır 2,5,6,7,11
String ifadeler içinde aynı kullanım geçerlidir
 
Ör:
         ("aaa", "aab", "aac","aad") ifadesi şu şekilde de gösterilebilir.
         ("aaa".."aad").
Benzer şekilde; ("BCY", "BCZ", "BDA", "BDB") ifadesi  ("BCY".."BDB"), ile aynıdır.
@alphabet = ("a".."z"); ifadesi bir alfabe listesini gösterir.
 
Örnek program: Program adı lstprg.pl olsun.
 
#!/usr/local/bin/perl
print ("Baslangic numarasini gir:\n");
 $basla = <STDIN>;
 chop ($basla);
  print ("Bitis numarasini gir:\n");
$bitis = <STDIN>;
 chop ($bitis);
@liste = ($basla..$bitis);
 $say = 0;
 print ("Liste yaziliyor:\n");
 while ($liste[$say] != 0  || $liste[$say-1] == -1
     || $liste[$say+1] == 1) #burada liste dizisinin sonu ve liste
                             #elemanı icinde 0 var mı kontrolu yapılıyor
         {
         print ("$liste[$say]\n");
         $say++;
 }
    
Çalısması:
 
>lstprg.pl
               Baslangic numarasini gir:
               -2
               Bitis numarasini gir:
               2
               Liste yaziliyor
               -2
               -1
               0
               1
               2
>
 
Örnek program : Program adı dizprg2.pl
#!/usr/local/bin/perl
 @dizi1 = (14, "ekmek", 1.23, -7, "su");
 @dizi2 = @dizi1;
 $say = 1;
 while ($say <= 5) {
          print("eleman $say: $array1[$say-1] ");
          print("$dizi2[$say-1]\n");
         $say++;
 }
 
Çalışması :
>dizprg2.pl
    eleman 1: 14 14
    eleman 2: ekmek ekmek
    eleman 3: 1.23 1.23
    eleman 4: -7 -7
    eleman 5: su su
>
 
 
Aşağıdaki kullanım şeklini inceleyelim.
 
Ör :
@liste1 = (2, 3, 4);
@liste2 = (1, @liste1, 5);
Sonuçta @liste2 dizisinin içeriği (içerdiği liste) şu şekildedir.
(1,2,3,4,5)
 
Örnek program : Program adı dizprg3.pl
#!/usr/local/bin/perl
  @al = " asla ";
  @yaz = ("Ben", @al, "kaybetmem!\n");
  print @yaz;
 
Çalışması :
>dizprg3.pl
 Ben asla kaybetmem!
>
 
Aşağıdaki parantez kullanımını inceleyiniz
$ali = "Ali";
print (("Hey, " . $ali . "!\n") x 2); 
Bu kodlama sonucu çıktı şöyle olur;
            Hey, Ali!
            Hey, Ali!
 
Dizilerde yerine koyma:
 
Şu örneğe bakalım.
@a = (1, 2, 3);
print (@a, "\n");
Çıktı
>  123
Burada bir problem var gibi...
 
Bir de şuna bakın,
@a = (1, 2, 3);
print ("@a\n");
Çıktı
>  1 2 3
 
Böyle olacaktı..farkı belirleyen kodlamayı inceleyin.
 
LİSTENiN UZUNLUĞUNU ELDE ETME:
 
@a = (1, 2, 3);
$skalar = @a;
 
Bu kodlama şekliyle biz @a dizisinin(oluşturan listenin) uzunluğunu elde ederiz. $skalar içindeki bu değer 3 tür.
 
Not:
$skalar = @a;
($skalar) = @a; 
yukarıdaki satırlar farklıdır.
1.satırda $skalar,@a dizisinin uzunluğunu tutar.
2.satırda $skalar,@a dizisinin ilk elemanını tutar. 
 
Dikkat ediniz...
Dizilerle çalışmayı iyice anlamak için aşağıdaki programların kodlanışlarını iyi inceleyiniz.
 
Örnek program : Program adı dizprg4.pl
#!/usr/local/bin/perl
@dizi = (14, "Peynir", 1.23, -7, "elma");
  $sayi = 1;
  while ( $sayi <= @dizi) {
          print("eleman  $sayi: @dizi[ $sayi-1]\n");
          $sayi++;
  }
Çalışması:
>dizprg4.pl
eleman 1: 14
eleman 2: Peynir
eleman 3: 1.23
eleman 4: -7
eleman 5: elma
>
 
Alt dizilerin kullanımı:
 
Örnek program : Program adı dizprg5.pl
#!/usr/local/bin/perl
  @dizi = (1, 2, 3, 4);
  @altdizi = @dizi[1,2]; 
                   # dizinin 2 ve 3 .elemanından alt dizi olustu.
                # hatırlayınız...dizinin 1.elemanı indisi $dizi[0] dır.
  print ("Altdizinin 1.elemanı: $altdizi[0]\n");
  print ("Altdizinin 1.elemanı: $altdizi[1]\n");
Çalışması:
>dizprg5.pl
Altdizinin 1.elemanı: 2
Altdizinin 2.elemanı: 3
>
 
 
Örnek program : Program adı dizprg6.pl
 #!/usr/local/bin/perl
 @dizi = ("bir", "iki", "üç", "dört", "beş");
 @sira = (1, 2, 3);
 @altdizi =  @dizi[@sira];
 print ("Dizi dilimi: @altdizi\n");
 
Çalışması :
>dizprg6.pl
 Dizi dilimi: iki üç dört
>
 
DİZİ dilimlerine ATAMA:
 
@a [0,1] = ("string", 46);
bu örnekte @a dizisinin ilk 2 elemanı değeri string ve 46 olur.
 
Ör : aşağıdaki satır sonucu
@a [0..2] = ("string1", "string2");
 
3.eleman null stringtir.
 
Ör : Aşağıda ise listenin 4.elemanı diziye atanamaz(dikkate alınmaz).
@a [0..2] = (1, 2, 3, 4);
 
Örnek program : program adı dizprg7.pl
 
#!/usr/local/bin/perl
@dizi = ("a1", "a2", "a3", "a4");
@dizi[1,2] = ("b2", "b3");
print ("@dizi\n");
 
Çalışması:
>dizprg7.pl
 a1 b2 b3 a4
>
 
Örnek program: Program adı dizsort.pl
 
#Okunan değerleri sıraladıktan sonra basan örnek
#!/usr/local/bin/perl
#giriş işlemi
  print ("Değerleri giriniz\n");
  print ("çıkış için boş satır giriniz.\n");
  $say = 1;
  $gir = <STDIN>;
  chop ($gir);
  while ($gir ne "") {
         @a [$say -1] = $gir;
        $say++;
        $gir = <STDIN>;
         chop ($gir);
 }
# sıralama işlemi
 $say = 1;
 while ($say < @a) {
        $x = 1;
        while ($x < @a) {
                 if ($a [$x - 1] gt $a [$x]) {
                        @a [$x-1,$x] = @a [$x,$x-1];
                 }
                 $x++;
         }
         $say++;
 }
#basma işlemi
print ("@a\n");
 
Çalışması:
>dizsort.pl
   Değerleri giriniz
   çıkış için boş satır giriniz.
    fok
    bebek
    dil
    bal
    bal bebek dil fok
>
 
 
Standart giriş (klavye ) den dizi okuma:
 
giriş dizi değişkenine yapılır.
Ör:
@a = <STDIN>;
 
Örnek program : program adı dizkey.pl
 
#!/usr/local/bin/perl
@a = <STDIN>;
print (@a);
 
Çalışması:
>dizkey.pl
    1.satır
    2.satır
    son satır.
   
 ^D    (control ve D tuşu)
 
    1.satır
    2.satır
    son satır.
>
 
DİZİ KÜTÜPHANE FONKSİYONLARI:
 
Dizilerde sıralama:
Bu işlem için kullanılan fonksiyon sort() dur.
 
Ör:  liste = sort (array);    
 
Ör:
@array = ("Bu", "bir", "test", "dir");
dizi bu şekilde oluştu. Şimdi sort ile sıralayalım;
@array2 = sort (@array);
sonuçta @array2 dizisi içeriği listesi şu şekildedir.
("bir", "bu", "dir", "test")
@array dizisi içeriği ise değişmez...aynıdır.("Bu", "bir", "test", "dir")
 
veriler alfabetik değilse;
 
@a = (70, 100, 8);
@a = sort (@a);
o zaman sıralama şöyle gerçekleşir.
(100, 70, 8)
 
Dizi değişken veya listeleri ters sıraya sokma:
Bu işlemi reverse() fonksiyonu yapar.
Örnek:
@a = ("bal", "incir", "arı", "sinek");
@a2 = reverse(@a);
@a2 içeriği listesi şu şekildedir:
("sinek", "arı", "incir", "bal")
 
Örnek program: program adı tersdiz.pl 
 
#program klavyeden girilen bilgileri ters olarak
# (alfabetik olarakbuyukten kucuğe)  sıralar
 #!/usr/local/bin/perl
 @input = <STDIN>;;
 @input = reverse (sort (@input));
 print (@input);
 
Çalışması :
>tersdiz.pl
    fal
    bal
    dil
    bez
 
    ^D
 
    fal
    dil
    bez
    bal
>
 
DİZİLERDE chop() FONKSİYONU:
 
chop() fonk.nun son karakteri sildiğini biliyoruz.
 
Ör :
$a = "Ala";
chop ($a);     
$var içeriği şu anda "Al" dır.
 
Dizi listelerinde kullanımı:
 
Ör:
@list = ("Aslan", "12345", "Geyik");
chop (@list);
 
Şu an @list içeriği liste şu şekildedir: ("Asla", "1234", "Geyi")
 
Başka bir örnek:
 
@a = <STDIN>;
chop (@a);
 
Bu şekilde klavyeden kullanımda yeni satır karakteri yok edilerek diziye alınır.
 
STRİNG LİSTESİNDEN TEK STRİNG OLUŞTURMA:
 
Bu görevi join() fonksiyonu yerine getirir.
 
Ör:
$string = join(" ", "bu", "bir", "liste", "dir");
$string içeriği şudur: "bu bir liste dir"
 
join da ilk " " kısmı stringler arasında kullanılacak karakteri bildirir. 
Yukarda ki örnekte bu karakter boş stringtir.
 
Aşağıdaki örneğe bakınca daha iyi anlayacaksınız.
   
$string = join("::", "kelime", "ve", "sütun");
 
sonuçta oluşan $string stringinin içeriği 
şöyle görünür :     "kelime::ve::sütun"  
 
Bir başka örnek:
@liste = ("Bu", "bir");
$string = join(" ", @list, "stringdir");
 
$string içeriği : "Bu bir stringdir" olur. 
 
Örnek Program:  program adı joprg.pl
 
#!/usr/local/bin/perl
@gir = <STDIN>;
chop (@gir);
$string = join(" ", @gir);
print ("$string\n");
 
Çalışması:
>joprg.pl
    Ben 
    perl
    öğrenmeye
    basladım.
 
    ^D
 
    Ben perl öğrenmeye basladım.
>
 
 
STRİNGLERİ AYIRMA:
 
split()fonksiyonu: join tersi işlev görür.
stringler arası karakter iki adet / karakteri arasında belirtilir.
$string = "bu::bir::ayırma::örneği";
@dizi = split(/::/, $string);
sonuc olarak @dizi içeriği şu şekildedir:
("bu","bir","ayırma","örneği")
 
 
bununla ilgili bir kelime sayma programını inceleyelim
program adı kesay.pl olsun
 
#!/usr/local/bin/perl
$kelimesay = 0;
$gir = <STDIN>;
while ($gir ne "") {
        chop ($gir);
        @dizi = split(/ /, $gir);
        $kelimesay += @dizi;
        $gir = <STDIN>;
 }
 print ("Toplam kelime sayısı: $kelimesay \n");
 
Çalışması:
 
>kesay.pl
   bu ilk satır
   bu da ikincisi
   son satır da bu olsun.
 
    ^D
 
    Toplam kelime sayısı: 11
>
 
Şimdi de son öğrendiklerimizi içeren bir örnek :
 
Klavyeden girilen kelimeleri ters sırada yerleştirip yazalım. Program adı fnk.pl
 
#!/usr/local/bin/perl
 
# Klavyeden girişini yap
 
  @giris = <STDIN>;
  chop (@giris);
 
# Her bir satırdaki kelimeleri ters sırada yerleştir
 
  $satir = 1;
  while ($satir <= @giris) {
         @kelime = split(/ /, $giris[$satir -1]);
         @kelime = reverse(@kelime);
         $giris[$satir -1] = join(" ", @kelime, "\n");
         $satir ++;
 }
 
#şimdi onların sırasını ters cevir ve yazdır
 
@giris = reverse(@giris);
print (@giris);
 
 
>fnk.pl
    bir iki
    üç dört
    beş altı.
 
    ^D
 
    altı. beş
    dört üç
    iki bir
>