|
Fonksiyonlar
Bir bilgisayar programının kalbi,
fonksiyonlardır. Fonksiyonlar, bir kere tanımlanır ve bir çok kereler,
ihtiyaç olduğu noktada hizmete çağrılır. Fonksiyonlar genellikle bir iş
veya hesaplama yaparlar ve bunun sonucu olarak ortaya yeni bir değer
çıkartırlar. Bu değere "fonksiyondan dönen değer" denir.
Fonksiyonun bir program için ne kadar
önemli bir unsur olduğunu bir örnekle belirtelim. Diyelim ki Web'de
öğrencilerimizin yıl içinde aldıkları notları gösteren bir programımız
var. Bu siteyi ziyaret eden öğrencilerin, iskterlerse, bir düğmeyi
tıklayarak, o andaki not ortalamalarını hesap ettirmelerini sağlamak
istiyoruz. Bu hesabı yapacak olan işlem, bir fonksiyondur. Web
ziyaretçisi düğmeyi tıkladığı anda, program, ortalama hesabını yapacak
olan fonksiyonu, o sayfada bulunan notları bildirecek; fonksiyon da
kendisine verilen bu değerlerle yapması gereken hesabı yapacak; ve elde
edeceği sonucu kendisini göreve çağıran program satırına bildirecektir.
Bildirilen bu değerle ne yapılacağı, fonksiyonu göreve çağıran komuta
veya işleme aittir. Fonksiyon kendisinden isteneni yapmakla yetinir.
PHP'nin kullanılmaya hazır bir çok
fonskiyonu vardır. Şu ana kadar sürekli kullandığımız echo() ve
print() bu tür PHP fonksiyonlarıdır. PHP'nin kendi
fonksiyonlarını göreve çağırmak, yine yukarıdaki örneklerde olduğu gibi,
program içinde gerektiği yere adını ve kullanacağı değeri yazmakla olur:
print ("Bu bir metindir!");
PHP bizim kendi fonksiyonlarımızı
kullanmamıza da izin verir. Fakat bunun için önce fonksiyonu
tanımlamamız gerekir.
PHP'de fonksiyonlar function komutu
ile oluşturulur. Tanımladığımız fonksiyon, kendisini göreve çağıracak
komuittan, yapacağı işlemde kullanmak üzere değer alacaksa, bu değerlere
vereceğimiz değişken isimleri fonksiyon adının yanında parantez içinde
gösterilir. Fonksiyon birden fazla değer bekleyecekse, bunların değişken
adlarının arasına virgül koyarız. Fonksiyona ulaştırılan değerlere
argüman denir. Fonksiyon, kendisine bir değer ulaştırılmasını
beklemese bile içi boş parantez koymamız gerekir. Buna göre PHP'de
fonksiyon şöyle yazılır:
function fonksiyonun_adı (argüman1,
argüman2, ... argümanN) {
fonksiyonun yapacağı işe
ilişkin komutlar
}
Fonksiyon adları, değişken adları ile aynı
kurallara tabidir. Fonksiyon içinden fonksiyon çağrılabilir;
fonksiyonların içinde PHP'nin kendi fonksiyonları kullanılabilir. Şimdi,
ilk örnek fonksiyonumuzu yazalım.
Yukarıdaki örneklerde, PHP'ye, bir Web
sayfası oluştururken HTML ögesi olacak bazı satırların başına <H1>,
satır sonlarına <BR> gibi etiketler koydurduğumuza dikkat etmiş
olmalısınız. Bir programda bu işi sık sık yapacaksak, yani metinlerimiz
<BR> ile bitecek, bazı başlıklarımız ise sayfamıza HTML'in başlık
etiketleri ile gönderilecekse, bu etiketleri defalarca yazmamız sadece
zorluk değil, fakat aynı zamanda yazım hatasını davet eden bir davranır
olur. PHP'de kendisine vereceğimiz metinleri başlık veya gövde yazısı
olarak biçimlendirecek fonksiyonlar tanımlayarak, programcılıkta daima
tehlikeli olan insan unsurunu asgarîye indirebiliriz. Şu programı
yazdir01.php adıyla kaydederek, Browser'da açın:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<?php
function yazdirBR ($metin) {
print ("$metin<br>\n");
}
function yazdirH1 ($metin) {
print ("<h1>$metin</h1>\n");
}
function yazdirH2 ($metin) {
print ("<h2>$metin</h2>\n");
}
function yazdirH3 ($metin) {
print ("<h3>$metin</h3>\n");
}
function yazdirH4 ($metin) {
print ("<h4>$metin</h4>\n");
}
function yazdirP ($metin) {
print ("<p>$metin</p>\n");
}
// Başka kodlar buraya girebilir
yazdirH1("Bu H1 Başlık");
yazdirH2("Bu H2 Başlık");
yazdirH3("Bu H3 Başlık");
yazdirH4("Bu H4 Başlık");
yazdirBR("Bu kendisinden sonra BR olan
birinci metin.");
yazdirBR("Bu kendisinden sonra BR olan
ikinci metin.");
yazdirP("Bu uzun uzun uzun uzun uzun
uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun
uzun uzun uzun uzun uzun uzun bir paragraf metni.");
yazdirP("Bu uzun uzun uzun uzun uzun
uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun
uzun uzun uzun uzun uzun uzun bir diğer paragraf metni.");
?>
</BODY>
</HTML>
Bu programda, yazdirBR(), yazdirH1(),
yazdirH3(), yazdirH4(), ve yazdirP() adlarıyla altı fonksiyon
tanımladığımızı görüyorsunuz. Bu fonksiyonların hepsi kendilerini göreve
çağıran satırdan, kendilerine bir değer verilmesini istiyorlar ve bu
değeri $metin adlı değişkende tutuyorlar. Fonksiyonlarımız tümü de
PHP'nin print() fonksiyonundan yararlanıyor; ancak bu fonksiyonun nasıl
kullanılacağını, nasıl işletileceğini de belirliyorlar. Buna göre bazı
fonksiyonlarımız $metin adlı değişkenin değerini önüne ve arkasına bir
HTML etiketi koyarak Browser'a gönderiyor; birisi ise sadece $metin
değişkenin tuttuğu değerin sonuna bir HTML etiketi koyduruyor.
Fonksiyonlarımı buradaki örnekte olduğu gibi hemen oluşturulduktan sonra
göreve çağırmayız. Geleneksel olarak, bir programda kullanılacak
fonksiyonlar, programın baş tarafında toplanır ve daha sonra nerede
gerekirse orada, çağrılırlar. Fonksiyonları adlarını ve kendilerine
verilmesi gereken bir değer varsa o değeri parantez içinde yazarak
çağırırız. Burada olduğu gibi, fonksiyonu göreve çağırırken parantez
içinde değerin kendisini yazabileceğimiz gibi, bu değeri tutan bir
değişkenin adını da yazabiliriz. Bu programı çalıştırırsanız, Browser'da
bu görüntüyü elde edebilirsiniz:
<php00012.tif>
Şimdi, bu penceredeki belgenin kaynağını
görüntüleyelim. Karşımıza şuna benzer bir metin çıkmış olması gerekir:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<h1>Bu H1 Başlık</h1>
<h2>Bu H2 Başlık</h2>
<h3>Bu H3 Başlık</h3>
<h4>Bu H4 Başlık</h4>
Bu kendisinden sonra BR olan birinci
metin.<br>
Bu kendisinden sonra BR olan ikinci
metin.<br>
<p>Bu uzun uzun uzun uzun uzun uzun uzun
uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun
uzun uzun uzun uzun bir paragraf metni.</p>
<p>Bu uzun uzun uzun uzun uzun uzun uzun
uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun uzun
uzun uzun uzun uzun bir diğer paragraf metni.</p>
</BODY>
</HTML>
Bu, bize, oluşturduğumuz bütün
fonksiyonların kendilerinden bekleneni yaptığını ve kendilerine
verdiğimiz metinleri, tıpkı istediğimiz gibi, arzu edilen HTML
etiketleri ile birlikte Browser'a gönderdiklerini gösteriyor.
Buradaki fonksiyon, kendisini bir iş yapan
türden fonksiyondur. Oysa kimi zaman fonksiyonlar, kendilerini göreve
çağıran komuta bir değer gönderirler. Şimdi de böyle bir fonksiyon
örneği yazalım. Aşağıdaki kodu, hesapla.php adıyla kaydedin:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<?php
function topla ($sayi1, $sayi2) {
$sonuc = $sayi1 + $sayi2;
return $sonuc;
}
function cikart ($sayi1, $sayi2) {
$sonuc = $sayi1 - $sayi2;
return $sonuc;
}
function carp ($sayi1, $sayi2) {
$sonuc = $sayi1 * $sayi2;
return $sonuc;
}
function bol ($sayi1, $sayi2) {
$sonuc = $sayi1 / $sayi2;
return $sonuc;
}
// Başka kodlar buraya girebilir
$sayi1 = 12;
$sayi2 = 5;
print topla($sayi1, $sayi2);
print ("<br>");
print cikart($sayi1, $sayi2);
print ("<br>");
print carp($sayi1, $sayi2);
print ("<br>");
print bol($sayi1, $sayi2);
print ("<br>");
?>
</BODY>
</HTML>
Bu programda, dört aritmetik işlemi yapan
dört ayrı fonksiyon tanımlıyoruz. Fonksiyonlarımız kendilerini göreve
çağıran komuttan, kendilerine iki değer vermesini bekliyorlar ve bu
değerleri $sayi1 ve $sayi2 adlı değişkenlere yazıyorlar. Sonra herbiri,
kendisinden beklenen aritmetik işlemi yaparak, sonucunu $sonuc adlı
değişkene yazıyor. Burada dikkat edeceğimiz nokta, return
komutudur. Bu komut, f onksiyonun elde ettiği değeri, değeri tutan
değişkenin adıyla, fonksiyonu çağırmış olan satıra gönderir. return
komutuyla, kendisini göreve çağıran satıra değil fakat mesela başka bir
fonksiyona da değer gönderebiliriz:
return ( baska_fonksiynon ( $degisken)) ;
Fonksiyonun return satırında böyle
bir başka fonksiyonun adı yazmıyorsa, bulunan değer göreve çağıran
satıra gönderilir.
Bu program, içine bizim yazdığımız iki
değeri hesaplayarak, Browser'a gönderecektir. Ancak bu değerler
ziyaretçinin dolduracağı bir formdan alınabileceği gibi, program
tarafından da hesaplanabilir
<php00013.tif>
Bu sayfanın kaynağındaki HTML kodları ise
şöyla olacaktır:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
17<br>7<br>60<br>2.4<br>
</BODY>
</HTML>
Fonksiyonlarımız, kendilerinden bekleneni
yaparak, gereken hesaplamanın sonucunu, kendilerini göreve çağıran
komuta, burada PHP'nin print() fonksiyona göndermiş; bu fonksiyon
da sadece bu sonuçları Browser'a iletmiş bulunuyor.
Buradaki örneklerde tanımladığımız
fonksiyonlara bekledikleri değerleri, onları göreve çağırdığımız noktada
biz veriyoruz. Ancak öyle durumlar olabilir ki, fonksiyonun beklediği
değerlerden biri veya bir kaçı, göreve çağıran satır tarafından
verilmeyebilir; fonksiyon varsayılan bir değerle çalıştırılabilir. Şu
örneği yazdir02.php adıyla kaydedin:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<?php
function yazdir ($metin, $boyut=3) {
print ("<font
size=\"$boyut\">$metin</font><br>");
}
// Başka kodlar buraya girebilir
yazdir("Bu Başlık", 5 );
yazdir("Bu küçük boyutta bir metin", 2);
yazdir("Bu varsayılan boyutta bir metin");
yazdir("Bu çok büyük Başlık", 8);
yazdir("Bu uzun bir paragraf metni. Boyutu
varsayılan ölçüde. Bu uzun bir paragraf metni. Boyutu varsayılan ölçüde.
Bu uzun bir paragraf metni. Boyutu varsayılan ölçüde.");
?>
</BODY>
</HTML>
Bu örnekte, daha öncekilerden farklı
olarak fonksiyonun, beklediği iki argümandan birisini, fonksiyonu
tanımlarken verdiğimize dikkat edin: " function yazdir ($metin,
$boyut=3)" ifadesi, PHP'ye, "Bu fonksiyona ikinci argüman eksik
gönderilirse, telaşa kapılma, onun yerine 3 rakamını kullan!" anlamına
gelir. Nitekim, programın daha ilerdeki bölümlerinde bu fonksiyon
görevlendirilirken birinci argümanın değeri olan metin verildiği halde,
iki ayrı yerde ikinci argümanın değeri verilmiyor. Bu iki durumda., PHP,
yazdir() fonksiyonunda varsayılan değer olan 3'ü kullanıyor.
<php00014.tif>
Bunu, görüntülenen sayfanın kaynağında
rahatça görebiliriz:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<font size="5">Bu Başlık</font><br>
<font size="2">Bu küçük boyutta bir
metin</font><br>
<font size="3">Bu varsayılan boyutta bir
metin</font><br>
<font size="8">Bu çok büyük Başlık</font><br>
<font size="3">Bu uzun bir paragraf metni.
Boyutu varsayılan ölçüde. Bu uzun bir paragraf metni. Boyutu varsayılan
ölçüde. Bu uzun bir paragraf metni. Boyutu varsayılan ölçüde. </font><br>
</BODY>
</HTML>
Programda, yazdir() fonksiyonunun ikinci
ve dördüncü kullanımında ikinci argümanın bulunmadığına, yukarıdaki
HTML'de bu satırlar için font size="3" etiketinin kullanıldığına
dikkat edin.
Yukarıda hesapla.php örneğini
birlikte yaptıysak, bir nokta dikkatinizi çekmiş olmalı: dört
fonksiyonda da aynı değişken adlarını kullanıyoruz ve sonucu aynı isimle
print() fonksiyonuna gönderiyoruz. PHP nasıl oluyor da, aynı isimli
değişkenleri buradaki gibi ayrı ayrı değerlerle ele alabiliyor? Bu
sorunun cevabını verebilmek için değişkenlerin kapsam alanına bakmamız
ve ve bu arada global deyimi ile tanışmamız gerekir.
Bir fonksiyonun değişkenleri, sadece o
fonksiyonun ömrü süresince vardır; hiç bir fonksiyon diğer bir
fonksiyonun değişkenlerinin veya kendisine verilmemiş bir başka
değişkenin değerini bilemez; kullanamaz. Bunu hemen bir örnekle görelim.
Şu kodu kapsam01.php adıyla kaydedin:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<?php
$metin = "Başkalarına yararlı olmanın
sınırı yoktur!";
function yazdir () {
print ("<h1>İşte metin: $metin
</h1>");
}
// Başka kodlar buraya girebilir
yazdir();
?>
</BODY>
</HTML>
Normal görünüşlü bir fonksiyon ve
kendisinden önce tanımlanmış olan $metin adlı değişkenin tuttuğu değeri,
kendisi göreve çağrıldığı anda Browser penceresinde görüntülemeye hazır
görünüyor! Fonksiyonun dışarıdan argüman istemediğini, kullanacağı
print() komutunun konusu olarak $metin değişkeninin değerini
kullanacağını da anlıyabiliyoruz. Fakat bu programı çalıştırdığımızda
karşımıza çıkan manzara çok farklı oluyor.
<php00015.tif>
Fonksiyonun çalıştığını, yazdırması
beklenen şeylerin ilk bölümünü yazdırmış olmasından anlayabiliriz.
Fakat, $metin değişkeninin değeri nerede? Şimdi bu sorunun cevabını
biliyoruz: $metin değişkeni fonksiyonun kapsama alanı (scope) dışında!
Bir fonksiyon kendisine verilmeyen veya kendi içinde tanımlanmayan bir
değişkeni kullanamaz; bilemez, değerinden haberi olmaz. Nitekim bu
görüntüyü aldığınız sırada kaynak kodlarına bakarsanız, "<h1>..</h1>"
etiketlerinin arasında sadece "İşte metin:" kelimelerinin bulunduğunu
göreceksiniz.
Bir fonksiyonun dışında tanımladığımız
değişkenlerimizi fonksiyona tanıtabilmek için global deyimini
kullanırız; böylece değişken bütün program boyuinca küresel nitelik
kazanmış olur:
Aynı kodun fonksiyon bölümünü şöyle
değiştirerek, kapsam02.php adıyla kaydedin:
function yazdir () {
global $metin;
print ("<h1>İşte metin: $metin
</h1>");
}
Programımızı çalıştırdığımızda, bu kez
metnin arzu ettiğimiz gibi görüntülendiğini göreceğiz.
<php00016.tif>
Bu noktada dikkat etmemiz gereken şey,
global deyimi ile kendisine kullanılmak üzere verilen değişken,
artık bir bakıma fonksiyonun malı olur ve fonksiyon tarafından değeri
değiştirilebilir. Bütün program boyunca kullanmaya niyetli olduğunuz
global değişkenlerin, kullanımına verildiği fonksiyon tarafından
değiştirilip-değiştirilmediğine dikkat edin.
Bir değişkenin bütün programda gerekli
olmadığı ve sadece bir fonksiyon içinde kullanılacağı durumlarda bu
değişkeni fonksiyonun içinde tanımlamak daha doğru olur. Fakat daha önce
belirttiğimiz gibi fonksiyonların içinde tanımlanan değişkenler
fonksiyon çalışırken var olur; fonksiyon sona erdiğinde de ölür. Başka
bir deyişle, bir fonksiyonun içinde oluşturduğumuz bir değişkenin
fonksiyon sona erdiğinde sıfırlanmaması için bir çare olması gerekir. Bu
çarenin adı, static deyimidir. Şöyle bir örnek düşünelim:
Sitemizdeki bir hesaplama fonksiyonu ziyaretçilerimizin yeni
alışverişlerinin toplamını eski toplama ekleyerek, yeni ana toplamı
buluyor ve ziyaretçi alışveriş sepetine yeni bir mal ekledikçe, ve o
andaki ana toplamın ne olduğunu öğrenmek istedikçe, fonksiyonumuzun eski
ana toplamı hatırlaması gerekiyor. Şu andaki PHP bilgimizle böyle bir
program yazmaya kalkmayalım; ama daha basit bir örnek olarak bu kodu
static.php adıyla kaydedelim:
<HTML>
<HEAD>
<TITLE>PHP'de Fonksiyon</TITLE>
<meta http-equiv="content-type" content="text/html;
charset=ISO-8859-9">
<meta http-equiv="Content-Type" content="text/html;
charset=windows-1254">
</HEAD>
<BODY>
<?php
function saydir () {
static $sayi = 0;
$sayi++;
print ("<h3>Fonksiyonun
tuttuğu sayı: $sayi </h3>");
}
// Başka kodlar buraya girebilir
print ("<h2>Fonksiyonun
birinci kez çağrılması:</h2>");
saydir();
print ("<h2>Fonksiyonun ikinci
kez çağrılması:</h2>");
saydir();
print ("<h2>Fonksiyonun üçüncü
kez çağrılması:</h2>");
saydir();
print ("<h2>Fonksiyonun
dördüncü kez çağrılması:</h2>");
saydir();
?>
</BODY>
</HTML>
Bu programı, static deyimi olmadan
çalıştıracak olursak, saydir() fonksiyonu her çağrıldığında $sayı
değişkeninin baştan tanımlandığını ve bir türlü 1'den ileri gidemediğini
göreceğiz. static ise fonksiyon bittikten sonra $sayi
değişkeninin değerinin değişmeden kalmasını sağlayacaktır.
Şimdi, bir PHP programının gerektirdiği
hemen herşeyi görmüş olduk; sadece iki özel araç, dizi değişkenler ve
nesneler (Objects) kaldı. Bunları da gelecek bölümde ele aldıktan sonra,
PHP'yi gerçek ortamda, Web'de kullanmaya başlayabiliriz.
|