Gokmen Portal - (PHP Programlama)

Your IP address
38.107.179.244

The Universal Declaration of Human Rights
Turkish - English

©CopyLeft by
Mustafa GÖKMEN
Konya / Turkiye, 2008.

Visitors

There are no copyrighted materials here.
All products, names and rights are respected to their owners.

KULLANICI TANIMLI FONKSİYONLAR

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.

Fonksiyon tanımlama ve çağırma

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 bir paragraf metni.");
yazdirP("Bu 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.

Şimdi, bu sayfanın 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 bir paragraf metni.</p>
<p>Bu 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, fonksiyonun 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_fonksiyon ( $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

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.

Fonksiyona varsayılan değer verebiliriz

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..");
?>
</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.

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

Değişkenlerin kapsamı: global ve static

Yukarıda hesapla.php örneğini 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.

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.

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.