WikiTurk
Editor Login | Register
Ekle

> Bilgisayar > Web Programlama

EL_MuHaMMeD
(Date : 6.12.2008 14:55:17)
imageimageimage %139


Perl Giriş ve Temel Bilgiler


 Reklam



PERL
Perl programlama dili aynı zamanda "Practical Extraction and Report Language" (Pratik Çıkarım ve Raporlama Dili) ve "Pathologically Eclectic Rubbish Lister" (Hastalıklı Derecede Eklektik ve Saçma Listeleyici) olarak da bilinir.

1987 yılının 18 Aralık günü Larry Wall tarafından dünyaya armağan edilmiştir. C, sed, awk, sh ve başka pek çok dilin önemli ve güçlü özelliklerini bünyesinde barındırmaktadır.

Yoğun şekilde metin işleme ve görüntü tanıma söz konusu olduğunda kullanılabilecek en güçlü ve pratik programlama dilidir. 17 yıldır geliştirilen ve özgür yazılım çerçevesinde kaynak kodu açık olarak sunulan Perl programlama dili hemen hemen tüm işletim sistemlerinde çalışmaktadır.

Perl ile ilgili sloganlardan biri: Perl programlarının %90’ı zaten yazılmıştır! Bunun sebebi CPAN yani Comprehensive Perl Archive Network olarak isimlendirilen ve Perl ile ilgili binlerce hazır modülü barındıran sistemdir. Bu madde yazıldığı esnada CPAN bünyesinde 3739 Perl geliştiricisi, 6646 Perl modülü bulunmaktadır. 2421 MB yer kaplayan sistemin 247 yansısı bulunmaktadır. Bunun anlamı şudur: Yapmayı düşündüğünüz bir işle ilgili modül, fonksiyon, sistem, vs. zaten yazılmıştır hazır olarak alıp kullanabilirsiniz.
( yukarıda yazılan genel bilgiler alıntıdır. )

Perl Komutları Nasıl Yazılır?

Öncelikle Arkadaşlar, İstediğiniz Bir txt Editörü ( Not Defteri ) Açıyoruz, İlk Satıra Perl’un İcra Edilebilir Dosyasının Sistemdeki Tam Yolu Verilir. Satır Başına Özel Karekterler (#!) Mutlaka Yazılmalıdır.

Örnek Verecek Olursak : #!/usr/bin/perl Şeklinde Başlanır..

Kodlama Bittikten Sonra Editörden Çıkılır, Unix ve Benzeri Sistemlerde o Dosyaya İcra Hakkı Vermeniz Gerekir. Varsayalım ki Program Adı deneme.pl olsun;

chmod +x deneme.pl Komutu Bu İşlemi Yerine Getirir.

Program Nasıl Çalışır ?

Komut Satırından Program Adını Girip Enter Tuşuna Basınız.

Örnek : deneme.pl

#!/usr/local/bin/perl
$girilensatir = <STDIN>;
print($girilensatir);

Bu Programın ilk Satırında Programın İcrası İçin Gereken Dosyanın Yeri Belirtilmiştir. İkinci Satırda Klavyeden Girilen Değer $girilensatir Değişkenine Aktarılır. (Burada By EL_MuHaMMeD Cyber-Warrior TIM yazalım). Üçüncü Satırda İse Bu Değer Ekrana Yazdırılır.

Ekrandaki Görüntüsü Şu Şekildedir.



Açıklama Satırları Nasıl Belirtilir. Açıklama Yapmak Amacıyla Kullanacağımız Satırların Başına ( # ) İşareti Koyarız.


Örnek :

# Bu Döküman CW nin Vefakar Üyelerine Hazırlanmıştır.
# Ama Bu Yazı Perl Tarafından Dikakte Alınmaz

Bu Duruma Göre Önceki Programımızı Şu Şekilde Kodlayalım;

#!/usr/local/bin/perl
# Bu Döküman CW nin Vefakar Üyelerine Hazırlanmıştır.
# Ama Bu Yazı Perl Tarafından Dikakte Alınmaz

$girilensatir = <STDIN>;
print($girilensatir);


Programın Çalışması Bir Önceki İle Tamamen Aynıdır. ( # ) İle Başlayan Satırlar Sadece Bizi Aydınlatmak, Not Tutmak İçindir. Perl Bu Satırları Değerlendirmeden Geçer.


Şimdi Şu Satırı Ele Alalım,

$girilensatir = <STDIN>;


Bu Satir Bir Perl İfadesidir (statement) Her Bir Parçasına( $girilensatir,=,<STDIN>,; ) İse Gösterge (token) Denir. $girilensatir Bir Skalar Değişkeni Belirtir. ( $ ) İsareti Değişkenin Skalar Olduğunu Girilen Satir İse Değişkenin Adını Belirler. ( = ) Göstergesi Kendisinin (bize göre) Sağındaki İfadeyi Solundakine Ata Anlamı Taşır. <STDIN> Standart Giriş Elemanını Yani Klavyeden Girişi İfade Eder. Son Olarak ; Göstergesi ise İfadenin Bitişini Gösterir ve İfade Sonlarında Mutlaka Bulunmalıdır Aksi Takdirde Hata Mesajı Alırsınız.


Yukarıdaki Açıklamalar Tüm Perl Benzer İfadelerinde Geçerlidir. Yazım Sırasında İstisnai Durumlar Dışında Karakter Aralarında Boşluk, Tab v.b Whitespaces Karakterleri Kullanılabilir. Aralardaki Boşluk Sayısı Önemli Değildir.


Gelelim Yazdırmaya


Standart Çıktı (ekran) ya Yazdırma Görevini Print Yapar.


print($girilensatir); İfadesiyle $girilensatir


Skalar Değiskeninin İçeriği Ekrana Yazdırılır. Aslında Print Fonksiyon Olarak Çalışır. $girilensatir ’ı ise Arguman Olarak Kullanır. Arguman 1 Den Fazlada olabilir.


print ($girilensatir, $girilensatir);


İfadesinde 2 Arguman kullanılmıştır. Her İkisi de Klavye Girişini Alan $girilensatir Değişkenidir. Bu Durumda Bu Satırın Çalışması Anında $girilensatir Değeri, Ekrana 2 Defa Yazdırılır.

Sabitler Konusu...
Şimdi sabitlere geçelim.

A) Sayısal Sabitler.

Sayısal Sabitler, Programın Çalışması Esnasında Gereken Sayısal Sabit Değerlerdir. Perl 8 ve 16 Tabanlı Sayısal Değerlerin Kullanımını da Sağlar.

1245
100.45
.000034
043
0x23
...gibi

B) String Sabitler:

String Sabitler, Programın Çalışması Esnasında Gereken Alfasayısal Sabit Değerlerdir. Alfabetik ve Alfabetik/sayısal/özelkarakter Karışımı Olabilirler. Tırnak İçindeki İfadelerdir. Perl Stringlerde; Tek, Çift, Geri Tırnak Kullanır. Bunlar Birlikte de Kullanılabilirler. Kurallarını Göreceğiz.

’Cyber Warrior’
"Cyber Warrior"
"Bilin ki, \\"O Sanal Alemin Kralıdır.\\""
’Buda EL_MuHaMMeD Farkıdır.’
...gibi

Stringlerde EscapeSequence Denilen Özel İşlevli Karakterlerde Kullanılır.
Escape SequeNCe Karakterlerinden Bazıları ve Anlamları:

\\a Alarm
\\b Backspace -geri-
\\e Escape -çıkış-
\\f Form Feed -form besleme -
\\n Newline -yeni satır-
\\r Carriage return -satır sonu-
\\t Tab - x karakter atla -
\\v Vertical Tab - dikey atla
-

Konumuzun Devamında Vereceğim Örneklerde Dahada İyi Anlayacağınızı Umuyorum.

Değişkenler...

a) Skalar Değişkenler :

İçersinde Değişebilen Değerler Bulunduran Birimlerdir. İlk Karakteri $ İşaretidir. Bu Karakterden Sonra en az 1 Alfabetik Karakter Bulunmalıdır. Değişken Adında Kural Olarak bu Karakterlerden Hemen Sonra Alfabetik, Sayısal Karakterler ve _ Karakteri Kullanılabilir. Değişken Uzunluğu Serbesttir.

$ad, $ad_soyad, $a1

Gibi Değişken Adlari Geçerli Olup Aşağıdakiler Geçersizdir.

ad # $ karakteri olmadığından
$ # $ dan sonra en az 1 alfabetik karakter gerektiğinden
$47x 2.karakter sayısal olamaz
$_ad # 2.karakter alfabetik olmalı
$ad! # ! karakteri kullanılamaz

Küçük ve Büyük Harf Kullanımı Önemlidir ve Farklı Değişkenleri Temsil Ederler. Bu Demektir ki; $AD ile $Ad ve $ad Farklı Değişkenlerdir.

Değişkenlere Değer Atama:

Eşitliğin Bize Göre Sağındaki Değer (sayısal/alfabetik/karışık olabilir) Solundaki Değişkenin İçine Konur. Aşağıdaki İfadeyi İnceleyiniz

$ADI_SOYADI = "Muhammed";
$ADI_SOYADI değişkeni içindeki değer "Muhammed"
dir.

Benzer Şekilde,

$MAAS = 125000;
$MAAS değişkeni içeriği 125000
dir

Değişkenin İçinde Önceden Bir Değer Varsa, Önceki Değer Silinir, Son Atanan Değer Geçerli Olur.

Aritmetik Operatörler:
Perl de Kullanılan TEMEL Aritmetik Operatörler;

Toplama +
Çıkartma -
Çarpma *
Bölme /


Örnek Program : Verilen Değerin Km ve Mil Cinsinden Çevirimini Yapar.

milkm.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
print ("Mesafeyi giriniz: \\n");
$mesafe = <STDIN>;
chop ($mesafe);
# chop fonksiyonu giriş sonundaki karakteri atar
# programımızda son karakter Enter tuşuna bastığımız için
# yeni satır (\\n) karakteri
# olduğundan onu atar(siler).
$mil = $mesafe * 0.6214;
$km = $mesafe * 1.609;
print ($mesafe, " km = ", $mil, " mil\\n");
print ($mesafe, " mil = ", $km, " km\\n");

Program Satırlarında Kullanılan "\\n" Göstergesi Alt Satıra Geçişi Sağlayan
Yeni Satır Karakteridir.

Çalışması:

milkm
>Mesafeyi giriniz:
>10
>10 km = 6.2139999999999995 mil
>10 mil = 16.09 km

a.1) Tamsayi (integer) Skalar Değişkenler:

İçerisinde Tamsayı Sabit ve Literal Bulundurabilirler. İntegerlar Kayar Noktalı (floating-point--birazdan inceleyeceğiz--) Değerler Gibi İşlem Görürler.

Örnek program: adı prg.pl olsun...

prg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$deger = 1234567890;
print ("1.değer: ", $deger, "\\n");
$deger = 1234567890123456;
print ("2.değer: ", $deger, "\\n");
$deger = 12345678901234567890;
print ("3.değer: ", $deger, "\\n");

Çalışması :

>prg
>1.değer: 1234567890
>2.değer: 1234567890123456
>3.değer: 12345678901234567168

Çıktısı Verir. Görüldüğü Gibi İlk 2 Değerde Sorun Yoktur. 3. Değer Yanlış Sonuç Üretir. Çünkü Tamsayı İçin Fazla Değer İçermektedir.

a.2) Kayar Noktalı (floating-point) Skalar değişkenler:

En Fazla 16 Rakam Kabul Edebilirler. Bu Değişkenler Tamsayı, Ondalıklı, Exponent(e üzeri) ve -/+ İşaretli Değerleri Saklayabilirler.

Örneğin, Aşağıdaki Değerlerle İşlem Yapabilirler.

11.4 , -275 , -0.3 , .3 , 3. , 5.47e+03 , ...v.b.


Örnek program : Adı prgsk1.pl olsun,

prgsk1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$deger = 34.0;
print ("1. deger ", $deger, "\\n");
$deger = 114.6e-01;
print ("2. deger ", $deger, "\\n");
$deger = 178.263e+19;
print ("3. deger ", $deger, "\\n");
$deger = 123456789000000000000000000000;
print ("4. deger ", $deger, "\\n");
$deger = 1.23e+999;
print ("5. deger ", $deger, "\\n");
$deger = 1.23e-999;
print ("6. deger ", $deger, "\\n");

Programın Çalışması :

> prgsk1.pl
> 1. deger 34
> 2. deger 11.460000000000001
> 3. deger 1.7826300000000001e+21
> 4. deger 1.2345678899999999e+29
> 5. deger Infinity
> 6. deger 0


b)String değişkenler:
String (karakter/karakterler içeren dizi) İçerirler. Bu Değerler Alfabetik ve Sayısal Sabit veya Değişken Olabilirler.

$AD_SOYAD = "Cyber Warrior";

Komutuyla "Cyber Warrior" Stringi $AD_SOYAD String değişkenine Atanır.

$number = 11;
$text = "Bu text sayı içerir. İçerdiği sayı $number.";


Komutlarının İcrası Sonucu $number’a 11 Sayısı Atanır. $text Değişkenine İse "Bu text sayı içerir. İçerdiği Sayı $number." Stringi Atanır. Sonuçta $text’in İçeriği Şudur.

"Bu text sayı içerir.İçerdiği sayı 11."

Stringlerde de Escape Sequence Karakterler Kullanılır.

Bunlar Aşağıdadır:

\\a Zil sesi
\\b Backspace
\\cn Ctrl+n karakteri
\\e Escape
\\E L, \\U or \\Q etkisini sonlandır
\\f Form Feed -
\\I Sonraki harfi küçüğe çevirir
\\L Sonraki tüm harfleri küçüğe çevirir
\\n Newline -yeni satır-
\\r Carriage return
\\Q Özel örnek karakterleri arama
\\t Tab
\\u Sonraki harfi büyüğe çevir
\\U Sonraki tüm harfleri büyüğe çevir
\\v Vertical Tab - dikey atla - 


Tek ve Çift Tırnaklı String Farkı:

Bunu Örnekle İnceleyelim.

$string = "Bir stringdir";
$text = "Bu $string";
# $text’in içeriği "Bu Bir stringdir"

Örnek 2:

$text = ’Bu bir $string’;
#$text’in içeriği ’Bu bir $string’

İki Örnek Arasında Fark Açıkça Görülmektedir. Tek Tırnak İçindeki String Aynen Saklanır. Değişken ve Hatta \\n Gibi Karakterlerde Kendi Özelliklerini İcra Eder Şekilde Kullanılamaz. (sadece \\ ve karakterleri hariç).

Örnek 3:

$text = ’Bu string.\\n’;
$text içeriği:
Bu string .\\n şeklindedir.

Örnek 4:

$text = ’Burada \\’, tek tırnak karakteri var’;
$text içeriği: Burada ’, tek tırnak karakteri var

Örnek 5:

$text = ’Stringin son karakteri backslash \\\\’;
$text içeriği:

Stringin Son Karakteri Backslash \\ Şeklindedir.

String ve Sayısal Değerlerde Değiştirilebilirlik:

Örnekle inceleyelim.

$string = "43";
$Sayı = 28;
$result = $string + $Sayı;
$result içeriği 71 dir.

Bir De Şu Örneği İnceleyelim:

number = <STDIN> #klavyeden giriş bekler 22 girdik diyelim
# $number içeriği 22\\n dir (\\n enter tusu)
chop ($number); # $number içeriği su anda 22

$result = $number + 1; #$result içeriği 23


Şöyle Bir Atama Sonucunda İse :

$result = "selam" * 5;
$result içeriği 0 dır.

Çünkü selam Sayısal Olmadığı İçin Sayısal Değeri 0 Dır.

Eğer String İfadede Sayısal ve Alfabetik Değer Varsa, $result = "12o34"; Dibi.. Bu Durumda Ortadaki ( o ) Harfi Öncesi Geçerlidir. $result İçeriği 12’dir.

ALTERNATİF STRİNG AYRAÇLARI
Aşağıdaki Örneğe Bakalım;

$say = 5;
print ("$say\\n"); # 5 basar
print (’$say\\n’); # $var\\n basar


Örnekte ve " Ayraçlarını Görüyoruz. Perl Başka Ayraç Elemanları da Sunar. Bu İşlev İçin, q Kullanıp Sonraki Ayraç Elemanını Belirleyebiliriz.

q!EL_MuHaMMeD $Kim! gibi...

bu ifade ile aşağıdaki ifade aynıdır.

’EL_MuHaMMeD $Kim’

String Sınırlayıcı Olarak qq Kullanırız.

qq/This string contains $var./

Burada / karakteri stringi ayırır(sınırlar).

Stringi Kelimelere Ayırma-Kesme- İşlevini qw İle Yaparız. Aşağıdaki İki Satır Aynıdır.

@kelimeler = qw/Cyber Warrior Tim/;

@kelimeler = split(’ ’, q/Cyber Warrior Tim/);

Her İki Durumda da @kelimeler ’ e Şu Liste Atanır;

("Cyber ", " Warrior ", " Tim")


( << ) Kullanarak String Tanımlama.

<< İşareti İle String Başı Tanımlanır. Bu String Boş Satır Görene Kadar Devam Eder.

$A = <<
here is the string
bu ikinci satır } $A içeriği yandaki ilk iki satırdır.
üçüncü satır
dördüncü satır


<< Sonra Konacak String, String Sonunu Belirler.

str = <<END (veya şu şekilde <<’END’ )

Bu Birinci Satır
Bu İkinci Satır

END (string sonu)


Şu Da Doğrudur.

$end = "END";
$str = <<"$end"

bu ilk satır
bu ikinci satır

END


Şu Kullanıma Bakın;

print <<END
Selamun Aleyküm
Anlıyorsunuz Umarım 
END


çıktısı 

Selamun Aleyküm 

Anlıyorsunuzdur Umarım
 

print <<END x 2 

Selamun Aleyküm 

END

çıktısı 

Selamun Aleyküm 

Selamun Aleyküm

$satır = <<END1 <<END2

birinci kısım

END1

ikinci kısım

END2

$satır içeriği

Birinci kısım

İkinci kısım

Not: \\n Dahildir.

<< Aralarında Boşluk Olmamalıdır.

Aritmetik Operatörler:

Yukarıda Temel Operastörleri Gördük (Toplama:+, Çıkarma:-, Çarpma:*, Bölme:/) Şimdi İse Üs Alma , Mod (artık) ve Unary Operatörlerini Görelim.

Üs Alma İçin ** , Mod için % , Unary Negation İçin - Operatörü Kullanılır.

Örnek:

$x = 2 ** 4 # 2x2x2x2 anlamındadır ..sonuçta $x içeriği 16 dır.
$y = 2 ** 2 # $y içine 4 atanır.
$x = 2 ** $y; # $x içine 2**4 yani 16 atanır.

Örnek program : Program Adı usprg.pl Olsun

usprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
#program 2 Rakamının Girdiginiz Deger Olarak Üssünü Bulur
print ("Kullanacaginiz üs degerini giriniz:\\n");
$us = <STDIN>;
chop ($us);
print ("2 nin $us .üssü = ", 2 ** $us, "\\n");


Çalışması :

>usprg.pl
>Kullanacaginiz üs degerini giriniz:
>16
>2 nin 16 .üssü = ", 65536
>

Negatif ve Noktalı Sayı Kullanmak Hataya Sebep Olur.

-5) ** 2.5 ..gibi

Yine Sınırları Aşan Sayılar Da Hataya Neden Olur.

10 ** 999999 ..gibi

MOD (Artık) Operatörü:

$x = 25 % 4;

Bu Örnekte 25,4’e Bölünür Kalan(artık) 1 Dir. Dolayısıyla $x ’in Değeri 1 Dir. İnteger Olmayanlar İnteger’a (Tamsayı) Dönüştürülür.

$x = 24.77 % 4.21;

Bu Örnekte 24, 4’e Bölünür Kalan Olmadığından $x Değeri 0 Dır.

MOD İşlemlerinde % İşaretinin Sağında 0 Olamaz Çünkü Sıfıra Bölme İmkansızdır. Bu Tür İşlemler Hata Mesajı Verir.

$x = 25 % 0;
$x = 25 % 0.1;


Unary Negation Operatörü:
- Operatörü

Değeri -1 ile Çarpmaktır.

- İşareti Bu Operatör İle Kullanımında Eksi İşareti Anlamında Değildir.

- 5; # Tamsayı -5’ e Esittir
- $y; # $y * -1 Anlamındadır.

Ayrıca -operant (azaltma), +operant (arttırma), Kullanım Öncesi Arttırma ++operand, Kullanım Öncesi Eksiltme Operand Kullanım Sonrası Arttırma Operand++, Kullanım Sonrası Elsiltme Operand--, Operatörleri de Kullanılır.
# Normal Yol:
$Sayfano = 5;
$Sayfano = $Sayfano + 1;
print($Sayfano, "\\n");
program çıktısı : 6


#Önceden arttırmalı yol:
$Sayfano = 5;
print(++$Sayfano, "\\n");
program çıktısı : 6


Önceden eksiltmeli operatör kullanımı.

$sayi = 5;
$toplam = --$sayi + 5;
print("$sayi $toplam \\n");
Çıktı : 4 9

sonradan arttırmalı opreratör kullanımı.

$sayi = 5;
$toplam = $sayi++;
print("$sayi $toplam \\n");
Çıktı : 6 5


Kıyas Operatörlerin Kullanımı:

$x = $a == $b;

Yukarıdaki Satırda $x in Değeri, $a ve $b Daki Değerlerin Durumuna Bağlıdır.

Şöyleki: Eğer $a,$b ye Eşitse, $a == $b Eşitliği Sonucu Doğru Değerini Taşır(true) ve $x in Değeri 0 OLMAZ. Sıfır Olmayan Değer Taşır. Eğer $a,$b ye Eşit Değilse, $a == $b Eşitliği Sonucu Yanlış Değerini Taşır(false) ve $x in Değeri 0 dır(Sıfır). Burada == Operatörünün Bir Kıyas İşlemi Yaptığını Görüyoruz. Kontrol İfadelerinde Koperatörleri Sık Sık Kullanılır.

Örneğin;

if ($a == $b) {
print("$a eşittir $b\\n");
}


Perlde, Kıyas Operatörleri 2 Sınıfta Kullanılır.

Sayısal işlemlerde
String işlemlerde


Tamsayı Kıyas Operatörleri:

Operatör Açıklama

< Küçük
> Büyük
== Eşit
<= Küçük veya eşit
>= Büyük veya eşit
!= Eşit değil
<=> Kıyaslama dönüşü 1, 0, veya-1

$a Değişkeninde 5 Varsa

$a > 4 sonucu true (doğru) veya 0 olmayan değer

$a > 7 sonucu false (yanlış) veya 0 dır.

<=> Operatörü Özel Bir Durum Arz Eder. Aşağıdaki 3 Değerden Birini Döndürür.

0, Kıyaslanan İki Değer Eşitse

1, ilk değer büyükse

-1, ikinci değer büyükse


String Operatörler

String Operatör Kıyas İşlemi Sayısal Operatör Karşılığı

lt Küçük <
gt; Büyük >
eq Eşit ==
le Küçük veya eşit <=
ge Büyük veya eşit >=
ne Eşit değil !=
cmp Kıyaslama dönüşü 1, 0, veya-1 <=>

Örnekler :

$result = "aaa" lt "bbb"; # Doğru
$result = "aaa" gt "bbb"; # Yanlış
$result = "aaa" eq "bbb"; # Yanlış
$result = "aaa" le "aaa"; # Doğru
$result = "aaa" ge "bbb"; # Yanlış
$result = "aaa" ne "aaa"; # Yanlış
$result = "aaa" cmp "bbb"; # -1


String - Sayısal Kıyas Karşılaştırması:
Aşağıdaki Örneklere Bakalım.

$sonuç = "123" < "45"; # 123 ile 45 sayısal değer olarak kıyaslanır..sonuç yanlış(false)
$sonuç = "123" lt "45"; # 123 ile 45 alfabetik değer olarak kıyaslanır sonuç doğru(true).



Floating-Point Sayılarda Kıyaslama:
Bu sayılarda Dikkat Edilecek Şey Ondalık Sonrasının Net Olmasıdır. Yuvarlanan Sayı Olursa Sonuç Hatalı Çıkar. Ne Demek İstediğim Aşağıdaki Örnekten Anlaşılacaktır.

floating_point.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$sayi1 = 14.3;
$sayi2 = 100 + 14.3 - 100;
print("sayi 1 : $sayi1, sayi 2 : $sayi2\\n");
if ($sayi1 == $sayi2) {
print("sayi 1,sayi 2 ye eşittir\\n");
}else {
print("sayi 1,sayi 2 ye eşit degildir\\n");
}

Çıktı:

sayi 1 : 14.300000000000001, sayi 2 : 14.299999999999997

sayı 1, sayı 2 ye eşit değildir

Mantıksal Operatörler ve Alt İfadeler :

Örnek:

$myval = $a || $b || $c;

Aşağıdaki İfadeyle Aynıdır.

if ($a != 0) {
$deger = $a;
} elsif ($b != 0) {
$deger = $b;
} else {
$deger = $c;
}


Örnek :

$deger = $a && $b && $c;

İfadesi Aşağıdakiyle Aynıdır.

if ($a == 0) {
$deger = $a;
} elsif ($b == 0) {
$deger = $b;
} else {
$deger = $c;
}

Atama Operatörleri:

Temel Atama Operatörü = Göstergesidir. $a = 5; # 5 Değeri $a Değişkenin İçine Yerleştirilir.

ATAMA operatörleri tablosu Operatör İzah

var = op1; op1,var ’a atanır(op1 değeri var içine yerleşir).
var += op1; var + op1 ,var’a atanır.
var -= op1; var - op1 ,var’a atanır.
var *= op1; var * op1 ,var’a atanır.
var /= op1; var / op1 ,var’a atanır.
var %= op1; var % op1 ,var’a atanır.
var .= op1; var. op1 ,var’a atanır.
var **= op1; var ** op1 ,var’a atanır.
var x= op1; var x op1 ,var’a atanır.
var <<= op1; var << op1 ,var’a atanır.
var >>= op1; var >> op1 ,var’a atanır.
var &= op1; var & op1 ,var’a atanır.
var |= op1; var | op1 ,var’a atanır.
var ||= op1; var || op1 ,var’a atanır.
var ^= op1; var ^ op1 ,var’a atanır.

Örnekler :

$result = 42; # $result ’un Değeri 42 Olur

$value1 = $value2 = "a string"; # Hem $value1,hem de $value2 nin

#içine "a string" atanır.

$var = $var + 1;

ile

$var += 1;

Aynı İşlemi İfade Eder. ($var değişkeninin değeri 1 arttırılır ve yeni değer tekrar $var’a konur)

Atama İşlemleri Örnekleri İçeren Bir Tablo İfade Kullanımı Yürütülen İşlem

$a = 1; 1,$a içine yerleşir
$a -= 1; $a = $a - 1;
$a *= 2; $a = $a * 2;
$a /= 2; $a = $a / 2;
$a %= 2; $a = $a % 2;
$a **= 2; $a = $a ** 2;
$a &= 2; $a = $a & 2;
$a |= 2; $a = $a | 2;
$a ^= 2; $a = $a ^ 2;

Alt İfadelerle Kullanım :

($a = $b) += 3;

Bu Örnekte İşleyiş Şöyledir. Önce Parantez İçi İşlenir. Bu Durumda $a = $b; ve $a += 3; İşlemleri Yapılır.

Otomatik Arttırma ve Eksiltme:

$a = $a + 1;
$a += 1;


Her İki Örnekte De $a Değeri 1 Artırılmaktadır. $a Değerini Otomatik Arttırma Kullanımı İse Şöyledir.

$a++; veya ++$a;

1. ve 2. ifadedeki fark şudur. 1.de arttırma işlemi atama işleminden önce 2. de sonra yapılmasını belirler. Otomatik eksiltmede buna benzer.Aynı mantıkla çalışır. Sadece işlem eksiltme şeklinde gerçekleşir.

$a--; veya --$a;

Örnek Program : Program Adı preprg.pl Olsun

preprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$sayi = 0;
while (++$sayi <= 5) {
print("Deger: $sayi\\n");
}
print("Son !\\n");

Çalışması :

>preprg.pl
Deger: 1
Deger: 2
Deger: 3
Deger: 4
Deger: 5
Son !
>

Örnek Program : Program Adı preprg2.pl Olsun

preprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$sayi = 0;
while ($sayi++ <= 5) {
print(" Deger: $sayi\\n");
}
print("Son !\\n");

Çalışması :

>prepprg2.pl
Deger: 1
Deger: 2
Deger: 3
Deger: 4
Deger: 5
Deger: 6
Son !
>


Bu Örneğin Çalışmasını Anlamak İçin Şu Tabloyu İnceleyelim.

$valueTest anında Sonuç $value Testten sonra
0 true (0 <= 5) 1
1 true (1 <= 5) 2
2 true (2 <= 5) 3
3 true (3 <= 5) 4
4 true (4 <= 5) 5
5 true (5 <= 5) 6
6 false (6 <= 5) 7 (while döngüsü çıkışı)

Stringlerde Otomatik Arttırma:

$string1 = "abc";
$string1++;

Şu Anda $string1 İçindeki Değer "abd" Dir.

Stringlerde Otomatik Eksiltme Olmaz ($string1--). Böyle Bir Durumda String İçindeki Değer -1 Olur.

$string1 = "aBC";
$string1++;

Şu Anda $string1 İçindeki Değer "aBD" dir.

$string1 = "abz";
$string1++; # $string1 içi "aca" dır.

$string1 = "AGZZZ";
$string1++; # $string1 içi "AHAAA" dır.

$string1 = "bc999";
$string1++; # $string1 içi "bd000" dır

String Birleştirme Ve Tekrarlama:

. operatorü, string birleştirir .
x operatorü, string tekrarlar.
.= operatorü, string birleştirir ve atama yapar.
Birleştirme :

$yenistring = "Cyber" . "warrior";

Satırı Sonucu Olarak $newstring Seğişkeninin İçeriği "Cyberwarrior" olur.

(.) Operatörü Değişkenlerle De Kullanılır.

Örnek:

$string1 = "Cyber";
$string2 = "warrior";
$yenistring = $string1 . $string2;
$yenistring değişkeninin içeriği " Cyberwarrior " olur.

Tekrarlama:

$yenistring = "t" x 5;
$yenistring değişkeninin içeriği "ttttt" olur.


x operatörü değişkenlerle de kullanılır.

Örnek:

$string1 = "t";
$tekrar = 5;
$yenistring = $string1 x $tekrar;
$yenistring değişkeninin içeriği "ttttt" olur.

x Operatörü Kullanırken x Etrafında Boşluk Bulunmalıdır.

$yeni = $eski x 5; #Doğru kullanım
$yeni = $eskix 5; # Yanlış "
$yeni = $eski x5; # Yanlış "



Birleştirme ve Atama:

$a = "Cyber";
$a .= "Warrior"; # $a nın değeri şimdi "CyberWarrior" dur.


Aşağıdaki Kullanımda Aynı Sonucu Verir.

$a = "Cyber";
$a = $a . "Warrior";


Örnek Program : Program Adı strcon.pl Olsun

strcon.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$sonuc = "";
print("Kelimeler giriniz çıkış için sadece enter basınız\\n");
$gir = <STDIN>;
chop ($gir);
while ($gir ne "") {
$sonuc .= $gir;
$gir = <STDIN>;
chop ($gir);
}
print ("Girilen kelimeler:\\n");
print ("$sonuc \\n");

Çalısması:

>strcon.pl
Kelimeler giriniz çıkış için sadece enter basınız
ben
sen
o
Girilen kelimeler: benseno
>



Diğer Operatörler:

, (virgül) Operatörü; İfadeyi Parçalara Ayırır.

Örnek:

$a1 += 1;
$a2 = $a1;

Datırları Virgül Kullanımı İle Şu Şekilde Kodlanır,

$a1 += 1, $a2 = $a1;

, Operatörü Atama İşlemlerinde Sıkça Kullanılır,

Örnek:

$val = 26;
$result = (++$val, $val + 5);


İlk Önce ++$val İşlenir Çünki Virgülden Öncedir $val,27 Olur. Sonra 5 Eklenir 32 Olur Bu Değer,$result ’e Atanır.

ŞART(Koşul) Operatörleri:

Bunlar ? ve : Operatörleridir.

Örnek:

$sonuc = $a == 0 ? 14 : 7;

Çalışmasını İnceleyerek Anlayalım; Eğer $a == 0 İse , $sonuc Değişkenine 14 Atanır, Değilse 7 Atanır. Yani Koşul Doğru İse ? Sonrası, Yanlış İse : Sonrası Atanır., Eğer Bu İşlemi İf Else İle Yapmak İsteseydik Şöyle Kodlayacaktık.

if ($a == 0) {
$sonuc = 14;
} else {
$sonuc = 7;
}

Bir De Şunu İnceleyelim;

$kosul == 43 ? $a1 : $a2 = 14;

Buradaki İşleyiş İse Şöyledir; Eğer $kosul İçindeki Değer 43 İse, $a1 ’e 14 Atanır. Değilse $a2’ye 14 Atanır..

Örnek Program : Program Adı pwdprg.pl Olsun

pwdprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
print ("Parola giriniz:\\n");
$parola = "ertan";
$giris = <STDIN>;
chop ($giris);
$sonuc = $giris eq $parola ? "Dogru parola!\\n" : "Yanlis parola.\\n";
print ($sonuc);


Çalışması:

>pwdprg.pl
Parola giriniz:
abc
Yanlis parola.
>

While Döngüsü:

Koşul İfadesi Doğru (true) İse Blok İçi Uygulanır. Değilse Blok Dışına(sonrasına) Çıkılır.


while ($sayi == 5) {
print ("Sayı 5!\\n");
}



Yukarıdaki Örnekte koşul ifadesi $sayı değişkeninin 5e eşitliğini test ediyor. Eğer 5 ise (true) oklu parantez içine (bloğa) geçilerek icra edilir. % değilse (false) blok dışına çıkılır.

Örnek Program : Program adı wh_dongu1.pl olsun.

wh_dongu1.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
$sayi = 0;
$sayac = 1;
print ("Bu satır döngü başlamadan evvel yazıldı.\\n");
while ($sayi == 0) {
print ("Dongu sayac değeri ", $sayac, "\\n");
if ($sayac == 3) {
$sayi = 1;
}
$sayac = $sayac + 1;
}
print ("Döngüden çıktık.\\n");

Çalışması :

>wh_dongu1
>Bu satır döngü başlamadan evvel yazıldı.
>Dongu sayac değeri 1
>Dongu sayac değeri 2
>Dongu sayac değeri 3
>Döngüden çıktık.
>


Until Döngüsü :

Genel formatı :

Until (Koşul İfadesi) {

Koşul İfadesi Sonucu Yanlış(true) İse

Blok İçi Uygulanır.

Koşul Doğru Olunca Blok Dışına Çıkılır

}

Örnek Program : Program Adı untilprg.pl Olsun

untilprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
print ("17 ARTI 26 SONUCU KACTIR.?\\n");
$dogru_cevap = 43; # Doğru cevap atandı
$girilen_deger = <STDIN>;
chop ($girilen_deger);
until ($girilen_deger == $dogru_cevap) {
print ("Yanlis! Yeniden dene!\\n");
$girilen_deger = <STDIN>;
chop ($girilen_deger);
}
print ("Bravo..Dogru cevap!!!\\n");

Çalışması :

>untilprg
>17 ARTI 26 SONUCU KACTIR.?
>39
>Yanlis! Yeniden dene!
>43
> Bravo..Dogru cevap!!!
>

Listeler:
Listeler Parantezlerle Sınırlandırılmış Skalar Değerler Dizisidir.

(1, 5.3, "CWJuba", 2)

Bu Listenin 4 Elemanı Vardır. 1 , 5.3 , CWJuba , 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 İç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ı İç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 İnceleyelim

$deger = 1;
@deger = (11, 27.1, "bir string");


Burada Var İsimli Değişkenler Tamamen Farklı Değişkenlerdir. $var Skalar Değişken Olup,@var İse 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 Eçin o Elemanın İndisi(numarası) Verilir.

Ör: $var = @array[0];

Burada @array Dizisinin 1. Elemanının İndis’i Verilerek(Dizilerde İlk Eleman Numarası 0 dır) o Elemanın Değerine Elaşılıyor ve Değer $var Değişkenine Atanıyor.D İzilerde

@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 İstenirse Veya Negatif (-) Değer Verilirse Atanacağı Değişken Değeri Null Stringidir Ki 0 a Eşittir.

Örnek:

@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 İnceleyelim.

@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,

Örnek:

$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 İşlem Görür.
Örnek:

$By_C0d3c[0] doğru
@By_C0d3c[0] ise yanlış kullanımdır.

Örnek Program: Program Adı dizprg.pl Olsun

dizprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
@dizi = (1, "By_C0d3c", 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 By_C0d3c
3 . eleman 1.23
4 . eleman "Tamam mi?"
5 . eleman 9.3300000000000005+e23
>

Örnek Program: Program Adı randiz.pl

randiz.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

# rand() Fonksiyonu İle 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
>

Listele Gösterimi:

(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) Gösterimi İle (1..10) Gösterimi Aynıdır. (2, 5..7, 11) Örneğinden Anlaşılan İse Şudur: Listenin 5 Elemanı Vardır. 2,5,6,7,11 String İfadeler İçinde Aynı Kullanım Geçerlidir

Örnek:

("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.

lstprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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
>

Ornek Program : Program Adı dizprg2.pl

dizprg2.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
@dizi1 = (14, "VolqaN", 1.23, -7, "CWHidden");
@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: VolqaN VolqaN
eleman 3: 1.23 1.23
eleman 4: -7 -7
eleman 5: CWHidden CWHidden
>

Aşağıdaki Kullanım Şeklini İnceleyelim.

Örnek :

@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

dizprg3.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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ı İnceleyiniz

$ali = "x-master";
print (("Hey, " . $x-master . "!\\n") x 2);


Bu Kodlama Sonucu Çıktı Şöyle Olur;

Hey, x-master!
Hey, x-master!

Dizilerde Yerine Koyma:
Şu örneğe bakalım.

@a = (1, 2, 3);
print (@a, "\\n");


Çıktısı..

> 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ı İnceleyin

Listenin Uzunluğunu Elde Etme:

@a = (1, 2, 3);
$skalar = @a;


Bu Kodlama Şekliyle Niz @a Dizisinin(oluşturan listenin) Uzunluğunu Elde Ederiz. $skalar İçindeki bu değer 3 tür.

$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.

Dizilerle çalışmayı iyice anlamak için aşağıdaki programların kodlanışlarını iyi inceleyiniz.

Örnek program : Program adı dizprg4.pl

dizprg4.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/usr/local/bin/perl
@dizi = (14, "Takva", 1.23, -7, "n0x");
$sayi = 1;
while ( $sayi <= @dizi) {
print("eleman $sayi: @dizi[ $sayi-1]\\n");
$sayi++;
}

Çalışması:

>dizprg4.pl
eleman 1: 14
eleman 2: Takva
eleman 3: 1.23
eleman 4: -7
eleman 5: nox
>

Alt Dizilerin kullanımı:
Örnek Program : Program Adı dizprg5.pl

dizprg5.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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

dizprg6.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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 İlk 2 Elemanı Değeri String ve 46 Olur.

Örnek : Aşağıdaki Satır Sonucu

@a [0..2] = ("string1", "string2");

3.eleman null stringtir.

Örnek : 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

Çalışması:

>dizprg7.pl
a1 b2 b3 a4
>


Örnek program: Program adı dizsort.pl

dizsort.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#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.

Örnek:

@a = <STDIN>;

Örnek program : program adı dizkey.pl

dizkey.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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.
>

Dizi Kütüphane Fonksiyonları:
Dizilerde sıralama:

Bu işlem için kullanılan fonksiyon sort() dur.

liste = sort (array);

@array = ("Bu", "bir", "test", "dir");

dizi bu şekilde oluştu. Şimdi sort ile sıralayalım;

@array2 = sort (@array);

Sonuçta @array2 Dizisi İç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 = ("EL_MuHAMMeD", "VolqaN", "DaiMon", "CWHidden");
@a2 = reverse(@a);


@a2 içeriği listesi şu şekildedir:

("VolqaN", "CWHidden", "EL_MuHAMMed", "DaiMon")

Örnek Program: Program Adı tersdiz.pl

tersdiz.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#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
>

Didiznlerde chop() FONKSİYONU:
chop() fonk.nun son karakteri sildiğini biliyoruz.

Örnek :

$a = "Ala";
chop ($a);

$var içeriği şu anda "Al" dır.

Dizi listelerinde kullanımı:

@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

joprg.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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

kesay.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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

fnk.pl Indir Göster Gizle Kopar Satır Gizle Satır Göster

#!/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
>

EL_MuHaMMeD Tarafından Derlenmiş, Bir Araya Getirilmiştir.



Derecelendir
Kaynak http://www.wikiturk.net
İçerik İhbarı



Open Source Document Project AUP&TOS