SİSTEM DEĞİŞKENLERİ

 

Perl de işlemleri kolaylaştıran çok sayıda sistem değişkeni vardır.Biz bunlardan çok kullanılan bir bölümünü inceleyeceğiz.

 

1) Genel skalar sistem değişkenleri

2) Pattern sistem değişkenleri

3) Dosya sistem değişkenleri

4) Dizi sistem değişkenleri

5) Hazır  dosya (built-in) sistem değişkenleri

 

1-) GENEL SKALAR DEĞİŞKENLER :

 

Programın gövde kısmında yaratılırlar. Skalar değişken davranışı gösterirler. Bunlar sadece bir değer depolarlar ve programda sadece bir kopyası tanımlanabilir.

 

 

$_

 

$_  :  Default skalar değişkendir. En sık kullanılandır.En son bulunan örneği içerir. Aşağıdaki fonksiyon ve operatörler $_ ile default olarak çalışırlar.

 

 

a) Pattern Bulma Operatörü ve $_ :

 

            Normalde pattern bulma operatörü depolanmış(değişkende) veriyi =~ veya !~ ile test eder.

 
Örnek : print ("merhaba") if ($val =~ /abc/); gibi...
 
default olarak pattern bulma operatörü $_ da depolu veriyi test eder. Bu demektir ki $_ ile =~ operatörüne gerek yoktur.
 
Yani;           print ("merhaba") if ($_ =~ /abc/);  yerine (ki bu da doğrudur)

       print ("merhaba") if (/abc/);  yazabiliriz.

 

Not : Eğer !~ (pattern bulunamassa doğru) operatörü kullanmak istersek onu $_ ile test ederken bile.

açıkça tanımlamalıyız

 

print ("merhaba") if ($_ !~ /abc/);

 

 $_, string ve pattern işlemlerinde de kullanılır.

 

$_ = "Stringin içerdigi sayi 25.11.";
 
@array = /-?(\d+)\.?(\d+)/;

 

ikinci ifadede gösterilen, her bir parantezle çevrili altpatern dizinin bir elemanı olduğundan. Sonuçta @array’a (25.11) atanır.

 

b) Yerine Koyma Operatörü ve $_

   
$val =~ s/abc/def/; ifadelerinde $val içinde abc aranır ve def onun yerine konur.
Yerine konmuş operatörü de $_değişkenini kullanır (eğer =~ kullanarak bir değişken tanımlamamışsanız.) 

 

Örnek : Aşağıdaki ifade, ilk bulduğu abc’yi $_içinde def ile değiştirir.

 
               s/abc/def/;              
 
benzer şekilde aşağıdaki ifade $_ içindeki tüm white space space,tab,newline)tek space ile
değiştirir.
   
   /\s+/ /g;                 
 
eğer örneklerimizdeki abc ile def yerine koymalarının kaç defa olduğunu bir değişkende tutmak istersek 
               
               $sayı = s/abc/def/g;  kodunu yazmamız yeterlidir.
 
 
c) Çeviri Operatörü ve $_ 
 
               Diğerleri gibidir mesela, $_ içindeki küçük harfleri büyüğe çevirmek için tr/a-z/A-Z/;  yeterlidir. Çevirim sayısını 
elde etmek istersek $sayı = tr/a-z/A-Z/; kullanırız.
 
Örnek program : tr kullanımını sağlayan program.Program adı program.pl ,içersinde karakterlerin(boşluk hariç) sayılacağı data dosyası ise dosya.dat olsun.
 
#!/usr/local/bin/perl
 print ("Saymak istediğiniz karakterleri giriniz:\n");
$stringsay = <STDIN>;
chop ($stringsay);
@karakterler = split (/\s*/, $stringsay);
while ($giris = <>) {
$_ = $giris;
foreach $karakter (@karakterler) {
eval ("\$say = tr/$karakter/$karakter/;");
$say{$karakter} += $say;
}
}
foreach $karakter (sort (@karakterler)) {
print ("$karakter  : $say{$karakter} adettir\n");
}
 
Çalışması : program.pl   dosya.dat
 
Saymak istediğiniz karakterleri giriniz:
et
e  : 9 adettir
t  : 6 adettir
 
 
d) <> operatörü ve $_ :
               
               Yukardaki örnek programda gördüğünüz gibi programın giriş satırını $giris skalar değişkenine okuyup onuda $_ a atıyordu. Bunun daha 
kısa yolu vardır.
 
while ($giris = <>) {
        $_ = $giris;
        .....
........ 
}
 
               yerine aşağıdaki kodu kullanmak
 
while (<>) {
.....
........ 
}
 
while ve for döngülerinde <> operatörünün kullanımı tüm girişleri otomatikman $_’a atar.

 

Örnek program :

 

#!/usr/local/bin/perl

while (<>) {

        ($ilkkarakter) = split (//, $_);

                    chop($_);              

         print ("$_ ifadesinin ilk karakteri:\t$ilkkarakter\n");

}

 

Çalışması : program pl

 

Turkiye Cumhuriyeti
Turkiye Cumhuriyeti ifadesinin ilk karakteri:   T
bu
bu ifadesinin ilk karakteri:    b
^D
 

Not : <> operatörü $_’a atamayı sadece, eğer döngüde bir koşul ifadesi durumunda ise gerçekleştirir.

 

 

e) Chop Fonksiyonu ve $_  :

 

            Default olarak chop fonksiyonu, $_ değişkeni üzerinde işlem yapar ve $_ içindeki değerin

            son karakteri chop tarafından silinir

           Yukardaki örnek programda  chop($_);  ifadesi yerine chop; ifadesi de kullanılabilirdi.             

 

while (<>) {
        chop;
......
}
 
 
f) Print Fonksiyonu ve $_ : 
 
               print’de $_’ı default kullanır. Print; satırında $_ içeriği standart output’a yazılır.
 

Örnek program :

 
#! /usr/local/bin/perl
 print while (<>);
 

    Burada giriş satırını okumak için <> operatörü kullanılır ve  o satır $_’a kaydedilir.

    Eğer satır boş değilse(klavyeden girilen satır da olabilir dosyadan okunan da)

    print fonksiyonu ile $_  içindeki o satır (klavyeden girdigimiz veya dosya adı verilmisse

    o dosyanın satırları) ekrana yazılır.

 
Çalışması : 
A) 
$ program.pl  dosya.dat
bu satır dosya.dat ın ilk satırı.
bu satır dosya.dat ın ikinci satırı..
$
 
B)
$ program.pl  
Bu satır ekrandan girildi
Bu satır ekrandan girildi
^D
$
 

Not : Bu default kullanım standart output için geçerlidir. Başka bir çıktıya yollanacaksa belirtilmelidir. Mesela $ içeriğini DOSYAM’a yazılacaksa print DOSYAM($_)  komutu geçerlidir.

 

 

$_ değişkenin diğer yararları : Bir çok şeyi perl’de pratik yapmamızı sağlar.

Mesela aşağıdaki örnekte –e kullanarak dosya1 ve dosya2 içeriği gösterilir.

 
$     perl -e "print while <>;" dosya1 dosya2

 

benzer şekilde dosya1 ve dosya2 içindeki mum ları nar yapar

 
$     perl –ipe "s/mum/nar/g"  dosya1 dosya2
 
 
 
                                                             $0
 

$0 : Program adı değişkenidir. Çalıştırdığınız programın adını içerir.

Mesela çalıştırdığınız programın adı prog1 ise;

 
print ("Calısan program $0...\n");
 
  ekrana;   Calısan program prog1...   yazar. 
 
Diğer programları çağıran bir program yazıyorsanız $0 değişkeni çok yararlıdır.Hata oluşursa siz hangi programın hata verdiğini anlayabilirsiniz.
   
     die ("$0: dosyası acılamadı\n"); 
 
Not: Hatanın tam olarak nerede olduğunu bulmak istiyorsanız sondaki \n karakterini kaldırmalısınız.
 
                                              $<     ve      $>
 
                               Kullanıcı Kimliği (User ID) Değişkenleri
 
               $<    gerçek userID                    $>        etkin userID 
 
               Gerçek userID programın bağlı olduğu userID dır, etkin userID ise söz konusu olan bir programa birleştirilen ID dir ki her zaman gerçek kullanıcı olmayabilir.
Bu değişkenler UNIX sistemindeki perl için geçerlidir. 
 
Örnek : 
 
 #!/usr/local/bin/perl
 ($kullanici) = getpwuid($<);
 ($kullanici1) = getpwuid($>);
 
  print ("Merhaba Gercek kullanici, $kullanici!\n");
  print ("Merhaba Etkin kullanıcı, $kullanici1!\n");
 
Çalışması;   program.pl
Merhaba Gercek kullanici, ertan!
Merhaba Etkin kullanıcı, ertan!
$
 
                                                                 $(       ve       $)
 
                                              Grup Kimliği (group ID) Değişkenleri
 
                                  $(   gerçek group ID             $)   etkin grup ID
 
               Bir önceki değişkenlere benzer özellikler bunlar içinde sözkonusudur.Sadece user yerine grup ifadesi geçerlidir.
 
                                                             $]
 
      $] :   Perl version numarası değişkenidir.
 
Örnek : 
 
#!/usr/local/bin/perl
$] =~ /Revision: ([0-9.]+)/;
$revision = $1;
$] =~ /Patch level: ([0-9]+)/;
$patchlevel = $1;
print ("revision $revision, patch level $patchlevel\n");
 
Çalışması; 
$ program.pl
$ revision 4.0.1.8, patch level 36
$
 
                                                             $/
 
$/ :  Giriş satırı ayıracı değişkenidir. Perl’de giriş anında bir satır karakter karakter okunur. Satır sonu \n ile anlaşılır. \n bir ayraç karakteri olarak düşünülebilir. İşte bu değişken kullanılarak ayraç karakterleri belirlenebilir, değiştirilebilir. Mesela 
$/’a null karakteri set edilirse, perl inputline ayracı olarak 2 adet \n karakteri var sayar.
 
Örnek : 
#!/usr/local/bin/perl
 
# Bu programda giriş yapılırken  : karakteri son karakter olarak kabul edilir
# diğer karakterler dikkate alınmaz 
 
$/ = ":";
$satir = <STDIN>;
print ("$satir\n");
 
Çalışması;
 
$ program.pl
Bu satir sonu ayrac denemesidir: Bu karakterler dikkate alinmayacak.
Bu satir sonu ayrac denemesidir:
$
 
 
                                                                $\
 
$\ : Çıktı satırı ayırac değişkenidir. Bu değişkendeki karakter her print den sonra otomatikman bastırılır.
Bu değişkende değişiklik yapacaksak  - l  seçeneği seçilir.
 
Örnek : 
#!/usr/local/bin/perl
$\ = "\n";
print ("Bu ilk satir.");
print ("Bu da ikinci.");
$\ = "\t";
print ("Bu ucuncu satir.");
print ("Dorduncu satir.");
 
 
Çalışması;
$ program.pl
Bu ilk satir.
Bu da ikinci.
Bu ucuncu satir.        Dorduncu satir.
$
 
 
                                                             $,
 
$, :  Çıktı için alan ayıracı değişkenidir. Bu değişken, print çağrıldığında basılacak elemanlar arasına konacak karakter(ler)i tutar.
Örnek : print ($a, $b);  kodu ile print önce $a’ı basar sonra $, içeriğini en son $b’yi basar. 
 
Örnek : 
#!/usr/local/bin/perl
$a = "Merhaba";
$b = "Ertan";
$, = " ";    #alan ayracı olarak bosluk(null) atanıyor.
$\ = "\n";  #sonlandırma ayracı ise yeni satır karakteri.
print ($a, $b);
 
Çalışması;
$ program.pl
Merhaba  Ertan
 
$
 
                                                                            
 
$” :   Dizi elemanları ayıracı değişkenidir.
 
Örnek : 
#!/usr/local/bin/perl
$" = "::";
@meyva = ("Elma", "Armut", "Muz", "Nar");                    
print ("@meyva\n");  
 
Çalışması;
$ program.pl
Elma::Armut::Muz::Nar
$
 
                                                                            $#
 
 
$# : Sayı çıktısı formatıdır. Bu değişken sadece Perl5 için geçerlidir. Normalde print fonksiyonu 20 rakam float point çıktı basma ayarına sahiptir. 
 
Yani;       print($x);      ile          printf ("%.20g", $x);        aynıdır.
Default formatı değiştirmek için $# değeri değiştirmelidir. Mesela hassasiyetin 15 rakam olmasını istiyorsak;  
               $# = "%.15g"; kodu  yeterlidir.
Görüldüğü gibi cins tanımlayıcı da tanımlanır. Tıpki printf ve sprintf’deki gibi. 
Yalnız bu değişkenin kullanımı pek tavsiye edilmemektedir. 
 
                                      $#diziAdı
 

$#diziAdı : Bu değişken dizinin son elemanının indisini tutar. Örneğin;

 

@meyva = ("elma", "armut", "nar");

$sonindex= $#meyva;

 

dizi 3 elemanlıdır. 0.eleman, 1.eleman ve 2.eleman.Son elemanın indisi görüldüğü gibi 2 dir.

$sonindex içeriği de 2 dir. Eleman indisi belirlemede $[ sistem değişkeninin etkili olduğunu unutmayalım. $[ default değeri 0 dır. Onun için dizinin ilk elemanının indisi 0 dır. Eğer bu değer

1 olursa dizininki de 1 den başlar.Bir $#diziAdı değişkeni her bir hazır dizi değişkenleri içinde tanımlıdır. Örneğin; $#ARGV, komut satırındaki eleman sayılarını tutar.

Aşağıdaki örnek $#dizi  kullanım örneğidir.

 

#!/usr/local/bin/perl

 

@ornek = ("Yıl",1999,"Ay",12);

for ($i = 0; $i <= $#ornek; $i++) {

print ("$ornek[$i]\n");

}

print ("$ornek[$#ornek]\n"); # son elemanın içeriği basılır (12)

 

çalıştır

 

Yıl

1999

Ay

12

12

 

$#dizi kullanarak, dizi uzunluğu kontrolü yapılabilir ve  bu değişkene istenilen değer atanarak o değer kadar elemanı içerecek şekilde dizi tanımlanabilir. Mesela;

@meyva = ("nar", "elma");

@meyva  dizisinin son indisi 1 dir(0 ve 1. eleman var). İstersek bu dizinin boyutunu artırabiliriz, değiştirebiliriz.

$#meyva = 10;    kodu,dizinin son indisinin 10 olduğunu belirler yani  dizi 11 elemanlı olmuştur(0-10)

Diğer elemanlar boştur. Eğer maximum boyutu azaltırsak geri kalanlar yok olur.

 
 
 
 
                                                                            $@
 
$@ :        Eval fonksiyonu hata mesajı değişkenidir. 
 
Örnek ifade : eval ("die (\"Bir sey olmadi\")"); ise bu satırda mesaj, $@ 'a atanır.
 Hata oluşursa Bir sey olmadi  at(eval) line1.  gibi bir mesaj verir.
$@ değişkeni ayrıca require fonksiyonu ile  oluşan hata mesajını döndürür. 
 
                                                                            $?                                                           
$? : Sistem hata kodu değişkenidir. Hata durumunu döndürür.
 
                                                                            $!
$!: Sistem hata mesajı değişkenidir. C dilindeki errno değişkeni ile aynıdır.
 
                                                                            $.
$. :          Bulunulan satır numarası değişkenidir. Mesela bir dosyadan satır okunurken okunmuş olan son satırın numarasını içerir. 
 
Örnek : 
#!/usr/local/bin/perl
open (DOSYA1, "dosya.dat") ||   die ("dosya.dat açılamadı\n");
open (DOSYA2, "dosya2.dat") ||  die ("dosya2.dat  açılamadı\n");
$input = < DOSYA1>;
$input = < DOSYA1>;
print ("Satır numarası $.\n");
$input = < DOSYA2>;
print ("Satır numarası $.\n");
$input = < DOSYA1>;
print ("Satır numarası $.\n");
 
Çalışması;
$ program.pl
Satır numarası 2
Satır numarası 1
Satır numarası 3
$



 
                                                                $*
 
$* :  Çok satırlı izleme (bulma) değişkenidir. Aslında patern aramalar tek satır gibi düşünülür. Ama çok satır varsa (text in tamamının içerisinde \n karakterleri vardır demektir) Sistem değişkeni $* içerisine 1 atanır. (default 0 ayarlanırsa çok satırlı pattern araması istenmiyor demektir )
                                                                            $[
 
$[ :    Dizinin 1. elemanının indisini tutan değişkendir. Default’u 0 olduğu için dizilerde 1. indis 0’dır. Eğer uygulama kolaylığı olsun diye 0 değil 1 yapmak istersek;
 
Örneğin : 
 
               1..    $[ = 1;
               2..    @meyva = ("nar", "muz", "kivi", "dut");
               3..    $ilk = $ meyva[1]; 
 
 kodlaması sonucu $ilk içeriği nar’dır Yani meyva dizisinin 1 nolu indisine (ikinci elemanı)
atama yapılmıştır.1.satırdaki tanım yapılmasa idi meyva dizisinin 0 nolu indisine yani ilk elemanına atanacaktı. Bu değişkende perl5’e aittir ve değiştirilmemesi (yani 0 kalması) iyi olur.
 
                                                                    $;
 
$; :  Çok boyutlu bileşik dizilerde indis(subscript) ayracı vazifesi gorur.
 
Örneğin : 
 
Perlde;     $degisken = $dizi{" nar "}{" bar "}; ifadesi geçersizdir. 2 boyutlu dizi yoktur. Bu tip diziye erişimi inceleyelim ;
 
$degisken = $dizi " nar "," bar "};
 
perl bu ifadeyi görünce onu şu şekle dönüştürür. 
 
$degisken = $dizi{" nar " . $; . " bar "};
 
$; değişkeni indis ayıracını tutar, otomatikman virgül koyarak iki dizi indisini ayırır.
 
Başka bir kullanım örneği :Alttaki iki satır da aynı  işlevi yerine getirirler.
 
$degisken = $dizi{"Ali", 4, "merhaba"};
$degisken = $dizi{"Ali".$;.4.$;."merhaba"};
 
ikinci satır $; değerinin(virgül) indislerin arasına girerek ayırdığını gösterir. 
 
$; değişkeninin default değeri \034 (Ctrl+\)’dir. Bunu isterseniz başka bir değere tanımlayabilirsiniz. $;’ın set edilmesi ile ilgili 
Örnek : 
#!/usr/local/bin/perl
$; = "::";
$array{"Ertan","No"} = 46;
$bir = $array{"Ertan","No"};
$iki = $array{"Ertan::No"};
print ("$bir, $iki\n");
 
Çalışması;
$ program.pl
46, 46
$
 
Not :     $; içine atanacak değer bir indis olarak kullandığınız karakter olamaz.
 
                                                                            $:
 
$: :          Kelime kesme ayıracıdır. Kelime bölme karakteri default olarak boşluk karakteri, \n karakteri ve – karakteridir. 
Kabul edilebilir kelime kesme karakterleri $: içinde depolanmıştır. 
Mesela bir satır belli bir uzunlukta ise ve format biçimi kısa ise uzun olanlar kesme karakterinde sonra dikkate alınmazlar. 
 
Örneğin :  Bu bir deneme satırıdır            (satır)
               ^<<<<<<<<<                      (format)   
               Çıktı;     bu bir 
               Olur. 2. boşluktan sonraki kelime formattan uzun olduğu için dikkate alınmaz. Boşluk kelime ayıracıdır, oradan kesilmiştir. Değerini değiştirebilirsiniz.( $: = " \n";) gibi...
 
 
                                                                            $$
 
$$ :     Perl yorumlayıcının prosesinin ID si (program proses ID’si aynı zamanda) değişkenidir.
 
                                                                       $ARGV
 
 $ARGV :  En son kullanılan dosya adını tutar.<> ile file dan ilk okutulduğunda file’ın adını $ARGV tutar. Buradan o an için kullanılan dosya bilinir.
 
Örnek : 
#!/usr/local/bin/perl
print ("Aratacaginiz stringi giriniz:\n");
$string = <STDIN>;
chop ($string);
while ($dosyaal = <>) {      # program adıyla birlikte komut satırından 
                                           # verilen dosya isimlerini alır
   if ($dosyaal =~ /$string/) {
   print ("$ARGV:$dosyaal");
   }
}
 
Çalışması;
$ program.pl  dosya.dat dosya2.dat dosya3.dat
Aratacaginiz stringi giriniz:
test
dosya.dat:Bu bir test dosyasıdır.
dosya3.dat:Bu bir test islemidir 
$
 
 
$^W :     İkaz mesajı basılıp basılmayacağını tutar 0 ise kapalıdır. 1 ile mesajı açar.
$^X :     Bu değişken programı komut satırından başlatırken ilk kelimeyi tutar.
               Programın adı ile başlamışsanız bu değişkende program adı vardır.
 
Örnek :
if ($^X ne "perl") {
        print ("Programa başlarken \n");
        print ("’Perl’ komutunu kullanmadınız");
}
 
2-) PATERN SİSTEM DEĞİŞKENLERİ :
 
               Şu ana kadar gördüğümüz sistem değişkenleri program içinde tanımlanmışlardır. Bundan sonrakiler sadece çalıştığınız ifade bloğunda tanımlıdırlar. (Bir ifade bloğu {} karakteri ile çevrelenmiştir.) Patern sistem değişkenleri, patern bulma operatörleri ve patern kullanan diğer operatörleri set eder. 
 
Bulunan Patern’i Tekrar Elde Etme
 
               Patern bulma veya yerine koyma operatörü için patern tanımladığımızda patern kısmı parantezle çevrelenir.
 
Örnek : /(\d+)\./     patterni, \d+ alt paternini parantezle çevreler. 
 
               Bu parantezler tabii ki patternin parçası değildirler ve bu alt pattern 1 veya fazla rakam bulma örneğidir. Bir pattern bulunduktan sonra sistem değişkenleri onları tutar $1,$2 gibi..
 
Örneğin, aşağıdaki pattern başarıyla bulunduysa.
 
   /(\d+)([a-z]+)/
 
bu durumda bulunan örnek 1 veya fazla rakam ve bir veya fazla küçük harf karakteri olmalıdır. Bu taktirde
 
$1 içeriği : 1 veya fazla rakam
$2 içeriği : 1 veya fazla küçük harften oluşur.
 
Örnek : dosya.dat içeriği şöyle olsun;
               45      45**32  34.57   10.5e+12
               445/14        5**32   39.57 + 18
programımız; 
 #!/usr/local/bin/perl
   while (<>) {
           while (/(-?\d+)\.(\d+)([eE][+-]?\d+)?/g) {
           print ("Tamsayı kısım $1, Ondalık kısım $2");
            if ($3 ne "") {
               print (", exponent $3");
            }
          print ("\n");
       }
   }
 
Çalışması;
$ program.pl    dosya.dat
Tamsayı kısım 34, Ondalık kısım 57
Tamsayı kısım 10, Ondalık kısım 5, exponent e+12
Tamsayı kısım 39, Ondalık kısım 57
$
 
dikkat, $1 yerine 1. bulunan için $0 kullanmayınız. Biliyorsunuz $0 program adını tutar.
 
* Önceki konularda işlenen \1,\2,\3 ....ile $1’i karıştırmayınız sadece pattern içinde tanımlıdırlar. Parantezlerin sayımı soldan başlar ilk bulunan $1’e konur.
 
Şu örnekte /(\d+(\.)?\d+)/ seçenek olarak decimal noktası içerebilen bir veya fazla rakam bulunur. Dolayısıyla pattern tümüyle tek bir değeri (parantezi) temsil eder. Tümüyle sonuç $1’dedir.
 
 
                                                                            $&
$& :  Patern’in Tamamını Elde Etme  
 
               Patern başarıyla bulunduğunda bulunan text string sistem değişkeni olan $& de saklanır. Bu bulunan patterni elde etme yoludur. Çünkü, patern bulucu true veya false döndürür. (paternin bulunmasının başarılı olup olmadığı) tabi bunun dışında paterni elde etmenin bir yolu daha vardır. Paternin tamamını parantezle çevreler ve $1 değerini kontrol edersiniz ama $&’den elde etme yolu daha kolaydır. Aşağıdaki program $& kullanarak giriş dosyası içindeki tüm rakamları sayar.
 
Örnek : 
#!/usr/local/bin/perl
while ($dosyaadi = <>) {
         while ($dosyaadi =~ /\d/g) {
                $rakamsay[$&]++;
          }
  }
  print ("Her bir rakam için toplam:\n");
  for ($i = 0; $i <= 9; $i++) {
         print ("$i: $rakamsay[$i]\n");
 }
 
Çalışması;
$ program.pl     dosya.dat
Her bir rakam için toplam:
0: 1
1: 4
2: 4
3: 4
4: 6
5: 7
6: 
7: 2
8: 
9: 1
$
   
Bu program bir anda 1 satır okur(komut satırında verilen dosyadan). 3.satır giriş satırından her bir değişkeni bulur. Bulunan rakamlar $&’a depolanır. 4. satır $&’ın değerini alır ve onu @rakamsay  dizisinin indisi olarak kullanır. Bu dizi her bir rakamdan kaç tane olduğunu sayar ve tutar. Tüm giriş dosyası okunduğunda sonuc basılır.
 
Not : $& değerine ihtiyacınız varsa, while döngüsü içinden veya bulunan patternin olduğu bloktan  çıkmadan onu elde ediniz.
 
 
                                                             $`    ve     
 
Bulunan Stringin Dışındaki text’i Elde Etme Değişkenleri :
 
               Pattern bulununca $&’a depolanacağından diğer text stringi ise diğer iki sistem değişkenine atanır.
·             ·             ·             ·             ·             Örnekten önceki kısım $`
·             ·             ·             ·             ·             Örnekten sonraki kısım  a atanır.
 
Örneğin, ertan1234ankara stringinde /\d+/ paterni ile, 1234 bulunur ve $&’a atanır. Rakam öncesi kısım olan ertan, $` ,   ankara ise   değişkenlerine  atanır.
 
 
 
                                                                  $+
 
$+ Değişkeni :      Bu değişken, parantezle çevrelenmiş son altpatterni  bulur.
 
Örneğin, aşağıdaki pattern’i dikkate alırsak,
 
                               /(\d+)\.(\d+)/
 
 $+ ,  ondalık noktası sonrasındaki patterni bulur. Yani $+ içeriğinde . sonrasındaki (\d+) patterni bulunur. Bu değişken çok yararlıdır.
 
 
3-) FİLE SİSTEM DEĞİŞKENLERİ :
 
Çeşitli sistem değişkenleri, file(dosya) değişkenleriyle birleştirilmiştir.
 
                                                                    $~
 
$~ : Default print format değişkenidir. Bir dosyayı tutar. Bu değişkeni biçimli yazdırma derslerinde de görmüştük.
Değiştirmek isterseniz ($~ değerini) aşağıdaki kodu mesela standart output için 
örnek verebiliriz.
select (STDOUT);  
$~ = "MYFORMAT";
write;
write komutu çıktı formatı için MYFORMAT biçimini kullanır.
 
                                                                   $=
$=   : Sayfa uzunluğu tanımlar.
 
               Select (“uzunluk”);
               $= = 72;
               uzunluk dosyası için sayfa uzunluğu 72 olur.
 
Not : Eğer sayfa başlık formatı tanımlanmışsa sayfa uzunluğu default olarak 60 dır. Sayfa başlık formatı (page headerformat) tanımlanmamışsa default sayfa uzunluğu 9999999 dır. 
Çünki Perl onun sürekli basılacağını varsayar. Eğer çıktı file’ı için başlıksız sayfa tanımı yapmak isterseniz boş sayfa başlığı tanımlayınız.
 
                                                                   $-
 
$-  : Listelenen dosyada artan (kalan) satırların sayısını tutar. Write ile satırlar yazıldıkça $- içeriği azalır. 0 olunca yeni sayfaya baslanır. Yeni sayfa başlayınca $= değeri; bu değişkeninde başlangıç değeri olur. 
 
Örnek 
#!/usr/local/bin/perl
open (BASKI, ">outfile");
select ("BASKI );       # BASKI default olarak set edilir
write;                       #yeni bir sayfa başlatır
print STDOUT ("write öncesi: $-\n");
write;
print STDOUT ("write sonrası: $-\n");
format BASKI =
Test Baskısıdır.
.
format BASKI_TOP =
Test baslik
.
 
 
Çalışması; program.pl
(Ekrana bastıkları)
write öncesi : 58
write sonrası: 57 
           
(outfile dosyasına yazdıkları)
            Test baslik
            Test Baskisidir.
            Test Baskisidir.
 
Not:        BASKI_TOP formatı         olmasaydı    
Ekrana,
               write öncesi : 99999999
               write sonrası: 99999998  
outfile dosyasına ise,
               Test Baskisidir.
               Test Baskisidir  yazardı.
5. satırda standart output a $- değeri gönderir. Standart output file’ı tanımdan dolayı burda BASKI dır.
 
                                                             $^
 
$^ :Sayfa başlığı formatı değişkenidir. Bu değişkenin tuttuğu sayfa başlığı formatı yoksa sayfa başlığı yoktur. 
$^ içeriğindeki değer sayfa başlığı formatı adıdır. Sayfa başlığı isminin default’u basılacak dosya adına TOP ilavesi ile oluşur. 
Önceki örnekte BASKI_TOP  buna örnektir
 
Yukardaki örneğe su satırı eklersek, print STDOUT ("baslik: $^");
Satırın ekrana bastığı değer  baslik: BASKI_TOP  olacaktır.
Bu değişkene atama da yapılabilir,
               Select(DOSYAM);
               $^=”BASLIK”;  ...gibi..
 
 
                                                                 $|
 
 
$|  : Buffer’lama Çıktısı Değişkeni (buffer kullanıldı mı? kullanılmadı mı?) :
 
               Bazı sistemlerde, print veya write kullanarak bir file’a çıktı yollandığında sistem ilk önce buffer olarak bilinen bir özel diziye çıktıyı gönderir.Buffer tamamen dolduğunda bir defada dosyaya yazılırlar. Bu çıktı buffer’lama olayıdır.
               Bazı durumlarda araya buffer sokmaksızın direkt olarak dosyaya yazmak isteyebiliriz. Mesela iki proses standart çıktıya aynı anda gönderilebilir. İşte $| değişkeni belli bir dosyanın bufferlanıp bufferlanmadığını belirler. Default olarak perl her bir çıktı dosyası için bir buffer tanımlar ve $| değişkeni 0’a set edilir. Bir dosya için buffer’ı devreye sokmamak için önce dosya seçilir sonra $| değişkenine 0’dan farklı değer set edilir.
 
Örnek : select ("DOSYAM");
$| = 1;
               
Bu ifade ile default çıktı dosyası olarak DOSYAM seçilir ve onun için bufferlama kapatılır. Bu işlem yazma işleminden önce yapılmalıdır.
 
                                                                 $%
 
$% :(current) Basılan sayfa değişkeni Perl’de açılan her output dosyası $% değişkeni ile ilişkilendirilir(birleştirilir). Bu değişken o anki sayfa numarasını tutar. Write, yeni bir sayfaya başladığında $%’ın değerine 1 eklenir. Herbir $% kopyasının başlangıç değeri 0’dır. İlk sayfa basıldığında 1’e set edilir. Sayfa Baslığı formatında bu değişken kullanılabilir.
 
 
4-) DİZİ SİSTEM DEĞİŞKENLERİ :
 
               Şu ana kadar gördüğümüz sistem değişkenleri skalar değişkenlerdir. Bundan sonrakiler dizi değişkenleri olacaktır. Bunlardan @_ değişkeni hariç diğerleri global değişkendir. Değerleri bir program içinde aynıdır.
 
                                                                    @_
 
@_ :        Alt programlarda tanımlıdır. Alt programa geçirilen argümaları liste halinde tutar.
 
Örneğin;
 
Ana program   ...........................................
 
&altprogram("merhaba", 2, $degisken);   #altprogram isimli altprogram devreye sokuluyor
.....                                                   # parentez içindekiler alt programa geçirilen değerlerdir
....
----Ana program sonu........................................
 
--Alt program kısmı------------------------------------
sub altprogram {
        local ($arg1, $arg2, $arg3) = @_;    #alt programa gönderilen değerleri bir liste
                                                                #halinde tutan değişken @_ dir.ve burada
            .....                          #tüm bu değerler sırayla  $arg1, $arg2,$arg3 e aktarılır.
.......
} 
Alt program sonu ---------------------------------------
 
Örnek : 
yukardaki gibi kodlanmış bir ana ve alt program örneğinden hareket edersek,
 
&altprogram("merhaba", 2, $degisken);   satırında alt program çağrılır ise alt programa geçirilen parametreler "merhaba", 2, $degisken ,  @_  içinde tutulurlar ve argüman olarak alt programa geçirilirler. Alt programlarda local tanımı ile skalar değişkenlere (lokal olarak tanımlı) @_ dizisi değişkenleri atanabilirler. 
 
                                                                   @ARGV 
 
 
@ARGV :  Perl’de program çalıştırma aşamasında, komut satırından bazı değerleri programa geçirebilirsiniz.Bu değerlerin tutulduğu değişken @ARGV dir.
Örneğin ; program.pl ertan 47 
Komutyla program.pl çalıştırılırsa, ertan ve 47 değerleri programa aktarılır. İşte bu değerler 
@ARGV dizisinde saklanırlar.  İsterseniz print(“@ARGV\n”); komutu bu değerleri ekrana basar. @ARGV aynı zamanda <> operatörleriyle birleştirilmiştir. Bu operatör, @ARGV içindeki elemanları dosya adı olarak değerlendirilir. Her bir dosya açılır ve sırayla okunur. 
Eeğer programın ana gövdesinde, alt yordam dışında shift fonkfiyonu çağrılmışsa, ve onunla argüman geçirilmemiş ise, perl @ARGV nin ilk elemanının silindiğini varsayar.Aşağıdaki döngü @ARGV nin  her elemanını, dönüşte $degisken içine atar.

while ($degisken = shift) {
# satırlar
}

 
5-) HAZIR DOSYA DEĞİŞKENLERİ :
 
STDIN, STDOUT ve STDERR
 
STDIN : Default input file’ı tutar.
STDIN’i  <> operatörü ile kullanırsak normalde keyboard’dan okur. Eğer yönlendirme operatörleri shell den girilmişse, STDIN  bir dosyadan okur.
 
STDOUT :Standart output dosyasını tutar bu da ekrandır. Eğer <,> gibi operatörlerle dosyalara yönlendirilmişse o dosya STDOUT dosyası olur. 
 
STDEER : Error dosyası olup ekrana ayarlıdır. Diğerlerinde bahsedilenler bunun içinde geçerlidir. Bu hazır değişkenleri open kullanarak diğer dosyalarla birleştirebilirsiniz.
(open (STDIN, "inputf"); gibi...
 
Bir dosya değişkenini standart file ile birleştirmek için <STDIN> ile yönlendirmeden sonra dosya adı olarak “-” tanımlayın.
 
Örnek :    open (ORNEKSTDOUT, "-");
 
Bir file değişkenini standart output file ile birleştirmek için filename olarak >- kullanılır.
 
Örnek :    open (ORNEKSTDOUT, ">-");
 
ARGV :  ARGV en son kullanılan dosyayı temsil eder. <> operatörü ile o anki okuma yapılan dosya ile birleştirilen özel file değişkenidir.
 
Örnek :    $satir = <>;            bu ifade ile o an kullanılan dosyadan okuma yapılır. Çünkü ARGV o anki okuma yapılan dosyayı temsil eder. 
 
Aşağıdaki kodla aynı şeyi ifade ederler.
               $satir = <ARGV>;
 
<> operatör yoluyla olması dışında, normalde ARGV’ye erişmeye pek ihtiyaç duymayız.
 
DATA :    Bu file değişkeni, özel _END_ değeriyle kullanılır ki bu değer program sonunu belirleyen değerdir.DATA ise _END_ satırından sonraki satırları alır ve kullanır.
 _END_ ‘den sonra DATA okutulursa size aynı dosyada başka bir program dahil etmenizi sağlar. Daha önce de bir örnek görmüştük.
 
Örnek 
#!/usr/local/bin/perl
$line = <DATA>;
print ("$line");
__END__
Bu benim kayıtım.
 
Çalışması;
$ program.pl
Bu benim kayıtım.
$
 
Programda _END_ program sonunu belirler. 3.satır DATA file dosyasından okur, _END_ den sonraki ilk satır okunur ve $line’a 
atanır. 
 
_  Underscore File Değişkeni :
 
               stat fonksiyonu veya file test operatörlerinden birisi ile en son çağrılan file’ı temsil eder.
 
Örneğin ;
$readable = -r "/u/public/dosyam";
 
$writeable = -w _;
 
2. satırdaki _ karakterinin temsil ettiği file değişkeni  "/u/public/dosyam"  ı temsil eder. 
 
 
 
Asıl yararı , birkaç file test operatörü ile kullanıldığında aynı dosya ismini tekrarlamak yerine kullanılır.
 
if (-r "dosyam.dat" || -w _ || -x _) {
 
        print ("dosyam.dat dosyasını okuyamam,yazamam veya çalıştıramam.\n");
 
}
 
 

`    İLE SİSTEM KOMUTLARINI ÇAĞIRMAK

 

$ben = `whoami`;       #whoami komutunu çalıştırır,çıktıyı $ben içine atar.

Print $ben;

    Çıktı:

 ertan

           

Şöyle de kullanılır;

 

$komut = "whoami";

$ben = `$komut`;

print "$ben"; 

   Çıktı:

            ertan

 

şu kullanımda olur,

 

$ben = qx#whoami#;   (qx, string sınır belirleyici olarak tanımladı)

print "$ben"; 

   Çıktı:

            ertan

 

 

qx ile ilgili not: eğer qx ile string sınır belirleyici karakter ( ise kapama karakteri ( değil, ) olur.

Örnek:$kim = qx(whoami);