OPERATÖRLER
Aritmetik Operatörler:
Daha evvel temel operatörleri görmüştük. (Toplama:+, Çıkarma:-, Çarpma:*, Bölme:/) Şimdi ise üs alma ,mod (artık) ve unary
operatörlerini görelim.
Üs alma için ** ,mod için % ,unary negation iç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
#!/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
>
NOT : Negatif ve noktalı sayı kullanmak hataya sebep olur
Ör: (-5) ** 2.5 ..gibi
Yine sınırları aşan sayılar da hataya neden olur
Ör: 10 ** 999999 ..gibi
MOD (Artık) Operatörü:
Ö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 integer'a(Tamsayı) dönüştürülür.
Ö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 işlemlerinde % işaretinin sağında 0 olamaz çünkü sıfıra bölme imkansızdır. Bu tür işlemler hata mesajı verir.
Ör: $x = 25 % 0;
$x = 25 % 0.1;
Unary negation operatörü:
- operatörü:
Değeri -1 ile çarpmaktır.
- işareti bu operatör ile kullanımında eksi işareti anlamında değildir.
Örnek : - 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.
Örnek :
# 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
Örnek : Önceden eksiltmeli opr kullanımı.
$sayi = 5;
$toplam = --$sayi + 5;
print("$sayi $toplam \n");
Çıktı : 4 9
Örnek : sonradan arttırmalı opr kullanımı.
$sayi = 5;
$toplam = $sayi++;
print("$sayi $toplam \n");
Çıktı : 6 5
KIYAS OPERATÖRLERİ KULLANIMI:
$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 işlemi yaptığını görüyoruz. Kontrol ifadelerinde kıyas operatö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.
1.Sayısal işlemlerde
2.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
|
Örnek :
$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 iki 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 işlemi
|
Sayısal opr.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ıyas Dönüş 1, 0, or -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 istediğim
aşağıdaki örnekten anlaşılacaktır.
#!/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
|| veya
! değil
$a || $b # ikisinden biri 0 olmayan değerse doğru
$a && $b # sadece her ikiside 0 olmayan değerse doğru
! $a # $a,0 ise doğru
Şu kullanım da doğrudur:
$a or $b # veya
$a and $b # ve
not $a # değil
$a xor $b # özel veya(birisi 0 olmayan değerse doğru,her ikisi ise değil)
Örnekler:
$a = 5;
$b = 0;
$a || $b; # true: $a, 0 değil
$b || $a; # true
$a && $b; # false: $b 0
! $a; # false: $a ,0 değil,dolayısıyla ! $a 0 dır.
! $b; # true: $b 0 dır dolayısıyla ! $b ,0 değildir
Bu operatörleri kontrol ifadelerinde bolca kullanırız
Ör :
if ($a1 == 26) {
if ($b2 > 0) {
if ($c1 eq "tamam") {
print("Koşullar tamam!\n");
}
}
}
Bu kodlamayı şu şekilde de yapabiliriz:
if ($a == 26 && $b > 0 && $c eq "tamam") {
print("3 koşulda tamam!\n");
}
Her ikisinin sonuçları da aynıdır.
$x == 0 || $y / $x > 5
Mantıksal operatörler ve alt ifadeler :
Ör :
$myval = $a || $b || $c;
aşağıdaki ifadeyle aynıdır.
if ($a != 0) {
$deger = $a;
} elsif ($b != 0) {
$deger = $b;
} else {
$deger = $c;
}
Örnek :
$deger = $a && $b && $c;
ifadesi aşağıdakiyle aynıdır.
if ($a == 0) {
$deger = $a;
} elsif ($b == 0) {
$deger = $b;
} else {
$deger = $c;
}
ATAMA OPERATÖRLERİ
Temel atama operatörü = göstergesidir. $a = 5; # 5 değeri $a değişkenin içine yerleştirilir.
ATAMA operatörleri tablosu
|
Operator
|
İ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ı işlemi ifade eder.
($var değişkeninin değeri 1 arttırılır ve yeni değer tekrar $var'a konur)
Atama işlemleri örnekleri içeren bir tablo:
|
İfade kullanımı
|
Yürütülen iş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 ifadelerle Kullanım :
Ör: ($a = $b) += 3;
bu örnekte işleyiş şöyledir. Önce parantez içi işlenir. Bu durumda $a = $b; ve $a += 3; işlemleri yapılır.
Otomatik Arttırma ve eksiltme:
$a = $a + 1;
$a += 1;
Her iki örnekte de $a değeri 1 artırılmaktadır. $a değerini otomatik arttırma kullanımı ise şö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.
Ör : $a--; veya --$a;
Örnek program : Program adı preprg.pl olsun
#!/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
#!/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 için şu tabloyu inceleyelim.
İşlem yürütme tablosu
|
$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 OTOMATİK ARTTIRMA:
$string1 = "abc";
$string1++;
Şu anda $string1 içindeki değer "abd" dir.
NOT : Stringlerde otomatik eksiltme olmaz ($string1--). Böyle bir durumda string içindeki değer -1 olur.
----***------
$string1 = "aBC";
$string1++;
Şu anda $string1 iç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.
-----***-----
STRİNG BİRLEŞTİRME VE TEKRARLAMA:
. operatorü, string birleştirir .
x operatorü, string tekrarlar.
.= operatorü, string birleştirir ve atama yapar.
Birleştirme :
$yenistring = "tas" . "kafa";
satırı sonucu olarak $newstring değişkeninin içeriği "taskafa" olur.
. operatörü değişkenlerle de kullanılır.
Ör :
$string1 = "tas";
$string2 = "kafa";
$yenistring = $string1 . $string2;
$yenistring değişkeninin içeriği " taskafa " 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.
Ör:
$string1 = "t";
$tekrar = 5;
$yenistring = $string1 x $tekrar;
$yenistring değişkeninin içeriği "ttttt" olur.
NOT !!!! : 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ış "
BİRLEŞTİRME ve ATAMA:
$a = "Ata";
$a .= "türk"; # $a nın değeri şimdi "Atatürk" dir.
Aşağıdaki kullanımda aynı sonucu verir.
$a = "Ata";
$a = $a . "türk";
Örnek Program : Program adı strcon.pl olsun
#!/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
>
DİĞER OPERATÖRLER:
, (virgül) operatörü; ifadeyi parçalara ayırır.
Ör: $a1 += 1;
$a2 = $a1;
satırları virgül kullanımı ile şu şekilde kodlanır,
$a1 += 1, $a2 = $a1;
, operatörü atama işlemlerinde sıkça kullanılır,
Ör: $val = 26;
$result = (++$val, $val + 5);
ilkönce ++$val iş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.
Ör: $sonuc = $a == 0 ? 14 : 7;
çalışmasını inceleyerek anlayalım;
eğer $a == 0 ise , $sonuc değişkenine 14 atanır, değilse 7 atanır.
Yani koşul doğru ise ? sonrası, yanlış ise : sonrası atanır.,
eğer bu işlemi if else ile yapmak isteseydik şöyle kodlayacaktık.
if ($a == 0) {
$sonuc = 14;
} else {
$sonuc = 7;
}
Bir de şunu inceleyelim; $kosul == 43 ? $a1 : $a2 = 14;
Buradaki işleyiş ise şöyledir;
Eğer $kosul içindeki değer 43 ise, $a1 'e 14 atanır. Değilse $a2'ye 14 atanır..
Örnek Program : program adı pwdprg.pl olsun
#!/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.
>
