Son zamanlarda bana gelen bu Flash oyun oynama hastalığı nerden geldi bilmiyorum ama bu site harika bir site sende hemen bu siteye gir ve oyun oyna . Hiç sıkılmadan oynayabileceğiniz harika oyunlar var. Ve bu oyunlar tamamiyle ücretsiz. Oyun oyna denildiği zaman ilk akla gelen site olan flashoyunlar1.net sitesi sizi oyun dünyasının en yeni en güzel oyunlarını oynamaya davet ediyor. Oyun oynarken sıkılmak artık yok alternatif güzel oyunlar sayesinde hiç sıkılmadan inanılmaz eğlenceli vakit geçireceksiniz.
jquery
Merhaba arkadaşlar bu gün nette jquery’i araştırırken jquery hakkında çeşitli bilgiler ve çeşitli eklentiler paylaşan bir blog ile karşılaştım.Çok güzel ve sade bizim gibi bir tema kullanıyorlar.Mutlaka ziyaret edip yeni şeyler öğrenmenizi isterim.Biliyorsunuz artık web sitelerimizin görüntü şıklığı açısından jquery vazgeçilmezlerimiz arasına girdi.Bu konuda var olan eksiklerimizi tamamlamak ve geliştirmek açısından ne kadar çok şey araştırıp öğrenir, paylaşırsak bu bize artı olarak geri döner.
jquery blog : http://jqueryarsiv.com
php de program denetimi
PHP’de Program Denetimi
Bilgisayar programı, belirli değerlere göre kendi izleyeceği yolu kendisi bulmalıdır. Bir Web programı da aynı mantıkla tasarlanır. PHP, bir kısmını daha önceki bölümlerde, bir kısmını da şimdi ele aldığımız araçları kullanarak, belirli durumlarda belirli istikametlere gidecek, yeri geldiğinde geri dönecek, yeri geldiğinde başka bölümlere sıçrayacak bir akış planı tasarlamamıza imkan verir.
Web programlarımızda, ziyaretçilerimizin sitemizde yaptıkları veya yapmak istediklerini bildirdikleri işe göre sayfalar, bu işlere göre sayfa içerikleri sunarız. Web programımız ziyaretçimizin hareket tarzına ve amacına uygun olarak ilerler. Bir programın akış planını kontrol etmemizi sağlayan unsurlar çoğu zaman programın kendi kendine karar vermesini sağlayan araçlardır. PHP’de program denetim unsurları, programın gidiş yönünü değiştirmemizi veya olduğu yerde durmasını ve beklemesini veya bir işi biteviye yapmasını sağlar. Bu bölümde bu araçları ele alacağız.
İnsan olarak kararlarımızı hemen hemen daima “bir şey öyle ise böyle, öyle değilse şöyle davranmak” üzere almaz mıyız? PHP programında if deyimi bunu sağlar. Kelime anlamı eğer olan if deyimi ile programımızı karar almaya zorlarız. Ne var programımız bizim kadar akıllı olamayacağı için if şartının doğru veya yanlış olması durumunda ne yapacağını da ona biz söyleriz. if deyimi şöyle yazılır:
if ( koşullar ) {
koşullar doğru ise yapılacak işlere ilişkin komutlar
}
elseif (diğer koşullar) {
diğer koşullar doğru ise yapılacak işlere ilişkin komutlar
}
else {
diğer her durumda yapılacak işlere ilişkin komutlar
}
PHP, if ifadesinin doğru olması halinde, ifadeye ait ilk süslü parantezin içindeki komutları icra eder; bu şartlar doğru değilse, elseif deyimi ile ileri sürebileceğimiz diğer bir grup şartın doğru olup olmadığını sınayabiliriz. Bu şartlar yerine geliyorsa, PHP, elseif bölümündeki işleri icra eder. Nihayet diğer her hangi bir durumda icra edilmesini istediğimiz komutları else bölümünde belirtiriz. PHP, if deyimi doğru değilse, deyime ait süslü parantezin içindeki işleri yapmadan yoluna devam eder; varsa elseif deyiminin şartlarını sınar; elseif bölümü yok fakat else bölümü varsa bu bölümdeki işleri icra eder. Deyimde else bölümü de yoksa, PHP yoluna if deyiminden sonraki ilk adımdan devam eder. Bunu bir örnekle belirtelim:
<?php
$sarki = “Güneş Doğacak”;
if ( $sarki == “Güneş Doğacak” ) {
echo (“Seçtiğiniz şarkının adı: Güneş Doğacak!”);
}
elseif ($sarki == “Beklerim Ben”) {
echo (“Seçtiğiniz şarkının adı: Beklerim Ben!”);
}
else {
echo (“Lütfen bir şarkı seçiniz!”);
}
?>
Çoğu zaman if deyimlerini birden fazla koşulu sınayacak şekilde yazarız; bununla birlikte elseif ve else bölümleri olmadan da yazılabilir:
<?php
if ( $parola == “” ) {
echo (“Sitemize girmek için parola yazmanız gerekir.<br>”);
echo (“Lütfen parolayı yazın! <br>”);
}
?>
Buradaki if deyimi $parola değişkeninin boş alfanümerik olması halinde ziyaretçiyi uyarak ve görevi bitecektir. Ziyaretçi bir parola yazmışsa, daha sonraki komutlar bu parolanın doğru olup olmadığını sınayabiliriz.
PHP’de program akışını yönlendirmekte kullandığımız bir diğer unsur, switch deyimidir. Adı anahtar anlamına gelen switch deyimi, verilen bir değişkenin değerinin sıraladığımız koşullardan hangisine uygun olduğunu sınar ve o koşula ilişkin komutları icra eder. PHP’nin yaptığı işi bitirdikten sonra switch deyiminin dışına çıkmasını sağlayan, break komutu vardır:
switch ( değişken ) {
case KOŞUL-1 ;
Koşul-1 doğru ise yapılacak işlere ilişkin komutlar
break;
case KOŞUL-2 ;
Koşul-2 doğru ise yapılacak işlere ilişkin komutlar
break;
case KOŞUL-3 ;
Koşul-3 doğru ise yapılacak işlere ilişkin komutlar
break;
case KOŞUL-4 ;
Koşul-4 doğru ise yapılacak işlere ilişkin komutlar
break;
………………….
………………….
default:
diğer her durumda yapılacak işlere ilişkin komutlar
}
switch deyimini yazarken mutlaka break ifadesini kullanmamız gerekmez; switch deyiminin akışı break ile kesilmemişse, program ilk şart yerine gelmiş olsa bile diğer şartları da sınamaya devam eder ve en sondaki default deyimine ulaşarak (default‘tan sonra noktalı virgül değil iki nokta üstüste işareti olduğuna dikkat edin), bu bölümdeki komutları icra eder. Ne var ki programcılık mantığına aykırı olabilir: bir değişkenin içeriği verdiğimiz şartlardan birini tutmuşsa, muhtemelen diğer şartları yerine getirmeyecek demektir. Bu durumda diğer koşulların sınanması gereksiz e default işlerin icra edilmesi ise hata olur. Bu deyimi de bir örnekle görelim:
switch ( $sarki ) {
case “Güneş Doğacak” ;
echo (“Seçtiğiniz şarkının adı: Güneş Doğacak<br>”) ;
break;
case “Derdime Derman” ;
echo (“Seçtiğiniz şarkının adı: Derdime Derman<br>”) ;
break;
case “Haberi Yok” ;
echo (“Seçtiğiniz şarkının adı: Haberi Yok<br>”) ;
break;
case “Sonsuza kadar” ;
echo (“Seçtiğiniz şarkının adı: Sonsuza kadar <br>”) ;
break;
default:
echo (“Seçtiğiniz şarkının adı bilinmiyor<br>”) ;
}
Programımız, bu kodu icra ederken,, $sarki adlı değişkenin değerini, buradaki dört isimle karşılaştıracaktır. Şarkının adı, “Güneş Doğacak” ise ilk durum gerçekleşmiş olacak; program Browser pencerisine şarkının adını yazacak (ve muhtemelen bu sözlerini görüntüleyecek!) ve ikinci adıma break ifadesine geçecektir. break, switch deyiminin sona ermesini sağlar; PHP yoluna, switch deyiminin kapanan süslü parantezinden sonra devam eder. Bu örnekte break ifadesi kullanılmamış olsaydı, PHP, diğer şartları da sınacak ve boşun azaman kaybedecekti; daha da garibi, en sondaki default komutu da icra edileceği için programımız Browser pencerisine hem seçilen şarkının adını, hem de “Seçtiğiniz şarkının adı bilinmiyor” yazacaktı. Bunu gözönünde tutarak, switch deyimini daima break ile birlikte yazmamız gerekir.
////////////////KUTU///////////////
Kimi zaman uzun uzadıya switch deyimi yazmamız gerekmeyebilir; bir değişkenin değerini sadece bir şarta uygunluk açısından sınamamız gerekir. Bunu soru ve iki nokta üstüste işaretleri (? … 
olarak yazılan işlemci ile yaparız. Diyelim ki, Web sitemizi ziyaret eden kişinin parola yazıp yazmadığını sıramak istiyoruz:
<?php
$uyari = ($parola == “” ) ? “Parola yazmanız gerekir” : “Teşekkür ederiz” ;
echo ($uyari);
?>
Bu kod parçacığı, ziyaretçinin parola girip girmediğini $parola değişkeninin içinin boş olup olmadığına bakarak anlayacak ve $parola değişkenin içi boş ise (yani soru işaretinin sorguladığı durumun doğru olması halinde) iki nokta üstüskte işaretinden önceki metni $uyarı değişkenin içeriği haline getirecek; $parola değişkeninin içi dolu ise (yani koşul yerine gelmiyorsa, durum yanlış ise) iki nokta üstüste işaretinden sonraki metni $uyarı değişkeninin içeriği yapacaktır. Bir sonraki echo() komutu ise içeriği bu sınav sonucuna göre belirlennen $uyarı değişkeninin değerini Browser penceresinde görüntüleyecektir.
/////////////////////////////KUTU BİTTİ///////////////
Yukarıdaki iki denetim ögesi de programın ileri doğru akışını bozmayan araçlardır. Oysa bazen programımızın bir koşul gerçekleşincele kadar yerinde sayması ve koşul gerçekleşmedikçe ilerlememesi gerekebilir. Kimi zaman da programımıza bir işi bitirmeden ileri gitmemesini biz bildiririz. Program akışının bu tür denetimini döngü deyimleri sağlar. PHP’de iki tür döngü vardır: bir durum devam ettiği veya etmediği sürece yapılan ve kaç kere tekrar edeceği bilinemeyen while döngüleri, ve tekrar sayısı belirli for döngüleri.
Bir değişkenin içeriğinin belirli bir şartı karşılaması veya karşılamaması halinde icra edilir. Burada dikkat edeceğimiz nokta, programın icrası sırasında değişkenin içeriğinin veya koşulun değişmesinin sağlanmasıdır. Aksi taktirde pıgramımız sonsuz döngüye girer ve muhtemelen çöker. while döngüsü şöyle yazılır:
while (koşul) {
Koşul doğru ise yapılacak işlere ilişkin komutlar
}
Bu yöntemin yaygın kullanıldığı alan, bir sayaçla yaptırılan işlerdir. Aşağıdaki programı while.php adılma kaydedip, çalışrırsanız, PHP, Browser’ın yazı türü boyutunu 1′den 7′ye kadar büyüterek, aynı metni yazdıracaktır:
<HTML>
<HEAD>
<TITLE>PHP’de Döngü</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
$sayac = 1;
while ( $sayac <= 7 ) {
print (“<font size= $sayac >”);
print (“<b><p>İyileri iyilikleri ile alkışlayınız!</b></p>”);
print (“</font>”);
$sayac ++;
}
?>
</BODY>
</HTML>
Programımız, while döngüsü içindeki iken, sonsuz döngüden kurtulabilmek için, yazıyı yazdırdıktan sonra, $sayac değişkenini bir arttırıyor. Aksi taktirde, değişken hiç bir zaman while döngüsünün beklediği şarta kavuşarak 7′ye eşit hale gelemeyecektir. (Programı, sondaki “$sayac ++;” satırını kaldırarak denerseniz, zararsız bir sonsuz döngünün ne olduğunu görebilirsiniz! Ama önce Browser’ın dur düğmesinin yerinde durup durmadığna bir bakın!)
while döngüsün aradığı şartın yerine gelmesi, her zaman burada olduğu gibi, tabir yerinde ise “elle” yapılmaz; döngünün icra ettiği komutlar veya fonksiyonlar koşulu içeren değişkeni değiştirebilirler. Sözgelimi elektronik ticaret sitemizde Web ziyaretçimizin while içinde yaptığı alışverişin tutarını koşul olarak kullanabiliriz ve bu koşulu içeren değişken alışveriş ile değişebilir.
while döngüsü farkettiğiniz gibi, ileri sürdüğümüz şartı, iyi yapmadan önce sınar; ve bu şart ortadan kalkmamışsa (yani henüz doğru/true ise) yapacağı işi yapar; başka bir deyişle while döngüsünün yapacağı iş hiç yapılmayabilir. Fakat sınamanın iş yapıldıktan sonra yerine getirildiği bir şekli de vardır: do..while.. Bu döngü ise şöyle yazılır:
do {
Koşul doğru ise yapılacak işlere ilişkin komutlar
}
while (koşul);
Burada gördğünüz gibi do..while döngüsü en az bir kere icra edilir; çünkü şartın sınanması yapılacak işe ilişkin komutlardan sonra gelmektedir. Bu döngünün aradığı şartın döngünün yaptığı işlerin sonucu veya kod bölümünde bizim tarafımızdan gerçekleştirilmesi için igerekli komutların bulunmasına dikkat etmelisiniz. Yoksa, bu döngü de sonsuzluğa erişir! Yukarıda örneği, bu yöntemle yazalım:
<?php
$sayac = 1;
do {
print (“<font size= $sayac >”);
print (“<b><p>İyileri iyilikleri ile alkışlayınız!</b></p>”);
print (“</font>”);
$sayac ++;
}
while ( $sayac <= 7 ) ;
?>
Bu döngüyü yazarken, while satırının sorunda noktalı virgül bulunduğuna dikkat edin.
PHP’de Web programlarımız, döngünün belirli bir sayıda olmasını ve mesela bu sayının bizim istediğimiz basamaklarda artmasını gerektiriyorsa, döngüyü for deyimiyle kurabiliriz. Ayrıca for deyimi sayaç gibi şartın yerine gelmesini sağlayacak arttırma veşa eksiltme işlemlerini kendisi yapacağı için, sonsuz döngüye girme tehlikesi de hemen hemen yoktur. Bu döngü şöyle yazılır:
for ( $yeni_degisken atama ; koşul ; artış basaması ) {
Koşul doğru ise yapılacak işlere ilişkin komutlar
}
for deyiminin ilk ögesi, döngü sayacı olarak kullanılacak bir değişken oluşkturulması ve buna değer atanmasına ilişkindir; sonra bir noktalı vrigül ile bu sayacın sınırı olan koşul belirtilir. Yine noktalı virgül ile ayırarak, sayaç değişkeninin artış hızı verilir. Bunu da yine yukarıdaki örnekle gösterelim:
<?php
for ($sayac = 1; $sayac <= 7 ; $sayac++ ) {
print (“<font size= $sayac >”);
print (“<b><p>İyileri iyilikleri ile alkışlayınız!</b></p>”);
print (“</font>”);
}
?>
Buradaki kod, while ve do..while göre çok daha kısa; ve while döngüsü sayacı arttırmayı sağlayan satır unutulsa bile çalışacağı halde, for döngüsü unsurlara ilişkin noktalı virgüller eksik olursa çalışmayacak ve bize böylece sonsuz döngü tehlikesini hatırlatmış olacaktır. for döngüsü kendi sayacını verdiğiniz şartı karşılayıncaya kendisi arttıracak, yani buradaki örneği göre $sayaç değişkeni 7 oluncaya kadar çalışacak ve şart karşılandığı anda, sona erecektir.
//////////////////KUTU///////////////
PHP’nin programcıya çok kolaylık sağlayan bir diğer döngüsü, foreach döngüsüdür. Ancak bir değişkenin bütün elemanlarını tekrar sayısında esas alan bu döngünün çalışma ilkelerini görebilmek için dizi değişken kavramını ele almış olmamız gerekiyor. Şimdilik bu döngünün varlığını bir kenara yazıp, dizi değişkenlere kadar, unutabilirsiniz.
////////////////////KUTU BİTTİ///////////////
Programımızın akışı, bazen döngünün durdurulmasını gerektirir. Örneğin, sayaç değişkenini ziyaretçinin vermesi gerektiği ve vermediği durumda, döngünün başlamaması yerinde olur. Programın gerektirdiği böyle bir sebeple döngüyü break komutuyla durduruz.
Sözgelimi aşağıdaki kodda kullandığımız $tekrar değişkenini değerini ziyaretçiden form yoluyla aldığımızı varsayalım:
<?php
$tekrar = 10 :
for ($sayac = 1; $sayac <= $tekrar ; $sayac++ ) {
if ( $tekrar <= 0 )
break;
print (“<font size= $sayac >”);
print (“<b><p>İyileri iyilikleri ile alkışlayınız!</b></p>”);
print (“</font>”);
}
?>
Bu kod parçasını, bir sayfa kodunun içine yerleştirir ve önce bu şekliyle, danha sonra $tekrar= 0 yazarak sınarsanız, break komutunun işe yaradığını göreceksiniz. ($tekrar değişkeninin değerini, Form yoluyla ziyaretçiden değişken değeri almayı öğreninceye kadar şimdilik kaydıyla biz yapıyoruz. Ayrıca buradaki if deyiminin süslü parantez olmadan yazıldığına dikkat edin.
break ifadesinin döngüyü tamamen durdurduğunu farkettiniz mi? Oysa programımızın akışı, kimi zaman da döngünün sadece belirli bir durumda kendisinden beklenen işi yapmamakla birlikte böyle tümüyle kesilmesini de gerektirmez. Yine yukarıdaki örneğe dönersek, sayaç değişkenini ziyaretçinin vermesi gerektiği ve vermediği durumda, döngünün tümüyle kesilmesini değil de, sadece sayacı gösteren $sayac değişkeninin sıfırdan büyük bir değere ulaşlmasını beklememiz yerinde olabilir. Bu devamlılığı continue komutuyla sağlarız:
Yine bu örnekte kullandığımız $sayaçc değişkeninin değerini ziyaretçiden form yoluyla aldığımızı varsayarak, kodu şöyle değiştirebiliriz:
<?php
$sayac = -5 :
for (; $sayac <= 7 ; $sayac++ ) {
if ( $sayac <= 0 )
continue;
print (“<font size= $sayac >”);
print (“<b><p>İyileri iyilikleri ile alkışlayınız!</b></p>”);
print (“</font>”);
}
?>
Bu durumda PHP, conktinue komutunu gördüğü anda for döngüsünün geri kalan kısmını icra etmek yerine başa dönecek ve döngüyü yeniden icra etmeye başlayacaktır. Döngünün ilk satırınnda kod parçasını, bir sayfa kodunun içine yerleştirir ve önce bu şekliyle, danha sonra $sayac= 1 yazarak sınarsanız, continue komutunun programı sayaç değişkeninin değeri 1 oluncaya kadar durdurduğunu ama bu sırada for döngüsünün devam ettiğini göreceksiniz. ($sayac değişkeninin değerini, Form yoluyla ziyaretçiden nasıl alacağımızı daha sonra göreceğiz.)
Buraya kadar, PHP programı oluşturabilmek için gerekli temel yazım kurallarını, yapıtaşlarını ve program akışında yararlanacağımız kontrol ögelerini ele almış olduk. Şimdi bu unsurların hepsini bir arada kullanabileceğimiz grupları, fonksiyonları ele alabiliriz.
Tarih ve saat Verisi
Tarih ve saat Verisi
PHP, o andaki zaman bilgisini, saat, dakika, saniye ve salise olarak; tarih bilgisini yıl, ay, gün (sayı veya isim olarak), programımızın herhangi bir yerinde bize bildirebilir. Bu bilgiyi Web sunucusunda istediğimiz anda, muhtemelen sunucunun bulunduğu bilgisayarın sistem saatinden alacak olan PHP, sunucu programında farklı bölgesel ayarlar için gerekli düzenleme yapılmışsa, bu imkandan yararlanarak bize sunucunun değil, arzu ettiğimiz bölgenin saat ve tarihini bildirebilir.
Özellikle Türkiye’de olmayan bir sunucuda bu imkanın bulunup bulunmadığını, ancak sınayarak veya sistem yöneticisine sorarak öğrenebiliriz. Böylebir sıNama için şu kodları programınızın başına koyun:
<?php
setlocale (“LC_TIME”, “TR”);
print (strftime (“Türkçe bugün günlerden: %A “));
?>
Browser penceresinde “Türkçe bugün günlerden Sunday” yazısını okursanız, sunucuda Türkçe için bölgesel ayar desteği yok demektir!
PHP’nin zaman ve tarih belirlemekte kullanabileceğiniz başlıca fonksiyonu getdate() ise şxöyle kullanılır.
getdate() Tarih ve saat bilgisini alır ve ve vereceğiniz bir isimdeki dizi-değişkende kaydeder. Örnek:
$saat_tarih = getdate()
Bu durumda, $saat_tarih dizi değişkeninde sırasıyla şu bilgiler yer alır:
32 saniye
57 dakika
6 saat
30 ayın gün sayısı (1-31)
0 haftanın gün sayısı (1-7)
7 ayın sayısı (1-12)
2000 yıl
211 yılın kaçıncı günü
Sunday günün adı
July ayın adı
964929452 Unix sistemlerinde Epoch biçiminde zaman bilgisi
PHP’nin tarih ve saat bilgisini biçimlendirmede yararlandığımız date() fonksiyonunu daha sonra metin biçimlerdirme bölümünde ele alacağız
php sabit değerler
Sabit Değerler
İster Web, ister Web-dışı amaçlı olsun, bir programın bazen başındanh sonuna kadar değeri değişmeyen değişkene ihtiyacı olabilir. “Değeri değişmeyen değişken” teriminin anlamsız olduğu kanısında iseniz, bunlara sabit değerler adını da verebilirsiniz! PHP’de sabit değerler, Script boyunca değişmeden kalır.
Sabit değerler, değişkenlerden farklı şekilde oluşturulur. Bunun için PHP’nin define() fonksiyonunu kullanırız. Bu fonksiyonun yazım kuralı şöyledir:
define (“SABIT_DEGER”, değer);
Burada SABIT_DEGER yerine, tanımlamak istediğimiz sabit değere vereceğimiz isim, değer yerine de sabit değeri yazarız. Örnek:
<?php
$Dolar_miktar = 125;
define ( “DOLAR_KURU”, 625675);
$TL_Tutar = $Dolar_miktar * DOLAR_KURU;
print ($TL_Tutar);
?>
Burada tanımladığımız DOLAR_KURU sabit-değeri, tıpkı bir değişken gibi kullanılabilir. Fakat bir sabit değeri tanımladıktan sonra içeriğini değiştiremezsiniz. Sabit değer ile aynı ismi taşıyan değişken oluşturmak mümkündür; ancak aynı ismi taşısa da bir sabit ile değişkeni (birinin adının önünde $ işareti bulunduğu için) karıştırmak kolay olmasa gerek.
Tanımlanmış olan bir sabiti yeniden oluşturamayız; ama buna teşebbüs ettiğimizde PHP hata vermez. Bir sabit değerin oluşturulmuş olup olmadığını defined() fonksiyonu ile anlayabiliriz:
<?php
$Dolar_miktar = 125;
if (defined( “DOLAR_KURU” )) {
echo (“Sabit değer daha önce tanımlanmıştı.<br>”);
}
define ( “DOLAR_KURU”, 625675);
$TL_Tutar = $Dolar_miktar * DOLAR_KURU;
print ($TL_Tutar);
?>
Bu programı, bu şekilde ve define() komutunu en üst satıra alarak çalıştırırsanız, ikinci çalıştırışınızda programın sabit değeri yeniden oluşturmayı reddettiğini görecektiniz. Sabit değerleri, Web sitesinde ziyaretçilerin girdiği verilerden alarak kendiliğinden oluşturan bir program yazdığınızda, defined() fonksiyonu mantıksal hata yapmanızı önler.
PHP’nin kullanılmaya hazır bir kaç sabid değeri vardır. True (doğru) değeri 1 olan, False (yanlış) ise değeri sıfır sayısı veya boş alfanümerik olan iki sabittir. Diğer sabitler şunlardır:
__FILE__ : O anda çalışmakta olan PHP dosyasının adı (kelimenin önünde ve sonunda iki alt-çizgi var);
__LINE__ : Bu ifadenin yer aldığı satırın sayısı (kelimenin önünde ve sonunda iki alt-çizgi var);
PHP_VERSION: PHP’nin sürümü (İki kelimenin arasında bir alt-çizgi var);
PHP_OS: PHP’nin çalıştığı işletim sistemi (İki kelimenin arasında bir alt-çizgi var);
PHP_VERSION : PHP’nin sürümü (İki kelimenin arasında bir alt-çizgi var);
Bunlara ek olarak, E_ERROR, E_WARNING, E_NOTICE ve E_PARSE şeklinde hata durumunda hatanın çeşitli özelliklerini bildiren sabit değerleri de kullanabiliriz.
PHP hakkında çok daha geniş bilgiyi phpinfo() fonksiyonunu çağırak alabilirsiniz.
php 4 yararlı fonksiyon
Dört yararlı fonksiyon
PHP’de değişken değer türü değiştirmekte kullanabileceğimiz kullanılmaya hazır fonksiyon vardır. ilerde döngüleri ele aldığımızda daha çok anlam kazanacak olan bu değişkenleri şimdilik bir kenara kaydedin:
isset() ve unset()
PHP, bir değişken tanımlandığı anda, sanki içinde değer varmış gibi, bilgisayarın belleğinde yer ayırır. Bu bazen bilgisayarın kıt kaynaklarını zorlayabilir. isset() fnksiyonu, PHP’nin bir değişkenin içinde değer bulunup bulunmadığını sınamasını sağlar. unset() ise varolan bir değişkeni yok eder. Bu iki fonksiyonu birlikte kullanabiliriz ve boş değişkenleri yok ederek, bilgisayarın belliğinde yer açabiliriz:
if (isset($bir_degisken)) {
print( $bir_degisken );
}
else {
unset($bir_degisken);
}
Bu kod parçası, $bir_degisken isimli dğişkenin içi boş değişse, içeriğini görüntüleyecek, içi boş ise varlığına son verecektir.
empty()
isset() fonksiyonun tersi işleve sahiptir; bir değişkene değer atanmamışsa, veya değeri sıfır veya boş alfanümerik (null string) ise, doğru (True) değeri verir.
$bir_degisken = 123;
echo empty($bir_degisken);
$bir_degisken = “”;
echo empty($bir_degisken);
Bu program parçası Browser penceresine sadece empty() fonksiyonun doğru sonuç verdiği birinci echo() deyiminde 1 yazdıracaktır.
is_string(),is_integer(),is_double(),
Sınadıkları değişkenin aradıkları türden değer içermesi halinde doğru ‘True) sonuç verirler.
<?php
$a = 6.567;
if (is_double($a)) {
print (“A Double’dır<br>”);
}
$b = “Reşit”;
if (is_double($a)) {
print (“B String’dir<br>”);
}
$c = 6;
if (is_int($c)) {
print (“C Integer’dır<br>”);
}
?>
Bu kod, Browser penceresine “A double’dır, B String’dir, C Integer’dır” yazdıracaktır. PHP’de bu fonksiyonlara benzeyen fakat başka tür değer arayan şu fonksiyonlar da vardır: is_array(), is_object.
intval(), doubleval(), doubleval()
Bir değişkenin değerinin türünü başka bir türe çevirmeye yararlar. intval(), ortaya çıkartacağı tamsayı değişkenin 10 tabanlı (decimal) veya 16 tabanlı (hexadecimal) olmasını sağlayan ikinci bir argüman alabilir:
<?php
$a = “123ABC”;
$b = inval($a, 16)
print ($b);
?>
Bu program Browser penceresine, 123′ün hexadecimal ifadesi olan “1194666″ yazdıracaktır.
Yukarıdaki örnekleri birlikte yaptıysak, = işaretini bol bol kullandık ve böylece PHP’nin bir çok operatöründen biriyle tanıştık. Buna PHP dilinde “atama operatörü” denir. Bu işlemci sadece yukarıda kullandığımız gibi, bir değişkenin bir değere eşitliğini ilan etmek amacıyla kullanılmaz. Örneğin:
print ( $sayi = 123 ) ;
ifadesinde olduğu gibi, bir fonksiyonun içinde de hem atama işlemi yapılabilir; hem de işlem yürütülür. PHP’nin aritmetik, birleşik-atama, birleştirme, karşılaştırma ve mantıksal sınama operatörleri vardır.
Aritmetik işlemciler:
+ Toplama 6+5 = 11
- Çıkartma 6-5 = 1
/ Bölme 6/5 = 1.2
* Çarpma 6*5 = 30
% Kalan (Modulus) 6%5 = 1
Aritmetik işlemleri gerçek sayılarla yaptığımız gibi, tuttuğu değer sayı olan değişkenlerle de yapabiliriz.
Daha önce, PHP’de değişken tanımlar ve bunlara değer atarken sayı olan değişkenleri tırnak işareti kullanmadan, alfanümerik değişkenleri ise tırnak içinde yazdığımızı hatırlayacaksınız. Bu, geleneksel hale gelmiş olan bir programcılık alışkanlığıdır. PHP, tırnak kullanmasanız da bir değişkenin sayı olup olmadığını anlar; daha sonra bu değişkenlerle aritmetik işlem yapabilir. PHP ayrıca rakamla başlayan alfanümerik değişkenleri sayı olarak kullanmaya kalktığınızda, bu değerin başındaki bütün rakamları sayı olarak kabul eder. PHP açısından harf veya işaretle başlayan alfanümerik değişkenlerin sayı olarak değeri sıfırdır. Örnek:
$a = 6;
$b = “22/A”
print ($a + $b)
sonuç olarak 28′i verecektir; veya
$a = 6;
$b = “A/22″
print ($a + $b)
sonuç olarak 6 çıkacaktır. Bu küçük deneyi yaparsanız, PHP ile program yazarken hangi değişkenin ne sonuç vermesi gerektiğini dikkatle düşünmek zorunda olduğunuzu görürsünüz. Bir kişinin geliri ile adresini toplamak, programcı olarak arzu ettiğiniz bir işlem olmayabilir!
Bununla birlikte elimizde bir kişinin adı ve soyadı ayrı değişkenler halinde ise, bunları birbirine ekleyerek (concatenation) ortaya yeni bir alfanümerik değişken çıkartabiliriz:
<?php
$adi = “Reşit”;
$soyadi = “Muhtar”;
$adi_soyadi = $adi . ” ” . $soyadi;
print (“<br>”);
print ($adi_soyadi);
print ($adi . “‘nın soyadı ” . $soyadi . “‘dir.”)
?>
Bu örnekte, sadece ekleme yoluyla yeni bir değişken oluşturmakla kalmıyoruz; fakat alfanümerik değişkenleri, başka metinlerle de birbirine ekleyebildiğimizi görüyoruz. Bu işlemi nokta işaretiyle (.) yapıyoruz. Bu işlemciyle sadece değişkenlerin değerlerini değil fakat metinleri de birbirine ekleyebiliriz:
<?php
print (“İyileri iyikleri ile alkışla; ” . “…” . “ve sen soluklarında daima Mesîh ol..! “)
?>
PHP’nin atama işlemcisinin eşittir (=) işareti olduğunu hatırlıyorsunuz birleşik-atama (combined-assignment) işlemcileri, bu işarete diğer aritmetik işlemciler eklenerek oluşturulur.
İşlemci Örnek Anlamı
+= $a += 5 $a = $a + 5
-= $a -= 5 $a = $a – 5
/= $a /=5 $a = $a / 5
*= $a *= 5 $a = $a * 5
%= $a %= 5 $a = $a % 5
.= $a .= “metin” $a = $a” metin”
Bu işlemi zihnimizde, “A değişkeninin mevcut değerine 5 ekle, çıkan sonucu A değişkenin yeni değeri yap!” şeklinde canlandırabiliriz.
Değerleri sadece 1 arttırmak veya azaltmak için PHP, bir kolaylık sağlar:
$a++veya ++$a: $a’nın değerini 1 arttırır;
$a–veya –$a: $a’nın değerini 1 eksiltir.
++ veya — işaretinin değişken adından önce veya sonra olmasının sonucu farklı olur. İşaretler değişkenin adından önce ise PHP önce değişkenin değerini bir arttırır veya eksiltir, sonra bu yeni değeri işleme katar; işaretler değişken adından sonra ise, PHP değişkenin o andaki değerini işleme kadar, sonra değeri bir arttırır veya eksiltir.
PHP’nin karşılaştırma yapması için kullandığımız işlemciler ise işlem işaretinin sağı ve solundaki değerleri veya değişkenlerin değerlerini işaretin belirttiği karşılaştırmayı yaptıktan sonra ortaya ya doğru (true) ya da yanlış (false) sonucunu çıkartırlar. Söz gelimi, değeri 6 olan değişkenin 5′ten büyük olup olmadığını sınarsak, sonuç doğru; 5′ten küçük olup olmadığını sınarsak sonuç yanlış çıkacaktır. PHP’nin karşılaştırma işlemcileri şunlardır:
İşlemci Örnek Örnek $a=6 ise:
== eşitse $a == 5 Yanlış/False
!= eşit değilse $a != 5 Doğru/True
=== aynı ise $a === 5 Yanlış/False
> büyükse $a > 5 Doğuru/True
< küçükse $a < 5 Yanlış/False
<= küçükse $a <= 5 Yanlış/False
veya eşitse
>= büyükse $a >= 5 Doğru/True
veya eşitse
PHP’nin karşılaştırma işlemcileri hem tam ve ondalık sayı türü değerlerle, hem de alfanümerik değerlerle kullanılabilir.
Daha ileri aşamalarda, bazen değişkenlerimizin karşılaştırmasının bu kadar basit olamayacağını; kimi zaman iki grup değişkenin karşılaştırılması gerektiği durumların bulunduğu göreceğiz. Diyelim ki, bir öğrencinin başarılı sayılması için hem vize notunun, hem de yılsonu sınav notunun belirli sayılardan büyük olması gerekiyor. Bu durumu ancak karmaşık-mantıksal sınamadan geçirmemiz gerekir. Bu sınamayı iki ayrı sınama sonucu ile birlikte kullanırız. Örneğin:
vize notu yeterli – final notu yetersiz = kalır (yanlış/false)
vize notu yeterli – final notu yeterli = geçer (doğru/true)
PHP’de bu karşılaştırmayı iki grubun arasına koyduğumuz işaretlerle yaparız İşaretin sağ ve sol tarafının doğruluğu veya yanlışığı işarete göre nihai sonucun doğru veya yanlış olmasını sağlar. Bu karşılaştırmaları yaparken şu işlemcileri kullanırız:
İşlemci Adı Anlamı Örnek
|| veya sol veya sağ doğru doğru || yanlış = doğru
or veya sol veya sağ doğru doğru || yanlış = doğru
&& ve sol ve sağ doğru doğru || yanlış = yanlış
and ve sol ve sağ doğru doğru || yanlış = yanlış
Xor Şartlı-veya Sadece sol veya sağ doğru doğru || yanlış = doğru
! Değil sol veya sağ yanlış doğru || yanlış = doğru
“veya” ve “ve” sınamaları için iki ayrı işlem işareti bulunmasının sebebi, PHP’nin işlem sırasıyla ilgilidir. Birazdan oraya geliyoruz. Şimdi, kavranması kolay olmayan ikili mantıksal sınamalara bir örnek verelim; yukarıda öğrencinin durumunu PHP komutu olarak yazalım.
<?php
$vize = 45;
$final = 65;
if ($vize >= 50 && $final >= 50) {
print (“Öğrenci geçti!”);
}
else {
print (“Öğrenci kaldı!”);
}
?>
Mantıksal karşılaştırma işlemleri daha da karmaşık olabilir. Örneğin, öğrencinin geçmiş sayılması için yılsonu vize ve final notlarının 45′dan yüksek, ve ya birinci sömester notunun ya da vize ve final notlarının ortalamasının 65′den yüksek olması şartı aranabilir. (Kabul; kötü bir örnek oldu. Ama sırf alıştırma için!) Bu durumda kodu şöyle yazmamız gerekirdi:
<?php
$vize = 45;
$final = 65;
$ilk_sem = 45;
$ortalama = ($vize + $final) / 2;
if (($vize >= 45 && $final >= 45) and ($ilk_se >= 65 || $ortalama >= 65)) {
print (“Öğrenci geçti!”);
}
else {
print (“Öğrenci kaldı!”);
}
?>
Burada, PHP önce || veya && işaretinin sonucunu bulacak sonra and veya or işlemcisinin gereğini yapaçaktır. Bu kodun vereceği sonucu, bilgisayarda çalıştırmadan tahmin edebilir misiniz? İpucu: Bu öğrencinin yerinde olmak istemezdim!
İşlem önceliği deyince.. Bütün programlama dilleri gibi PHP için de işlemlerin hangi sırada yapıldığı önem taşır. “5 + 4 * 2″ işleminin sonucu, önce 5 ile 4′ün toplanması ve sonucun 2 ile çarpılması halinde başka, 4′ün 2 ile çarpılması ve sonucun 5 ile toplanması halinde başka olacaktır. Bu bakımdan, PHP’nin hangi işlemi önce yaptığı, hangi işlemi sonra yaptığını bilmemiz gerekir. PHP’deki işlemlerin yapılış sırası şöyledir:
++ ve –
/ * %
+ -
< <= => >
== === | =
&&
||
= += -= /= %= .=
and
xor
or
r.
php escape
turler.php dosyasını yazdıysanız, şu satırdaki, ters-bölü işareti dikkatinizden kaçmamış olmalı:
print “İkinci değişkenin adı: \$alfanumerik<br>”;
Daha önce gördük ki, tek veya çift tırnak içine de alsak, PHP, bir değişken adını gördüğü zaman onun yerine o değişkenin tuttuğu değeri yazar. PHP bunu, değişken adının başındaki $ görerek yaparak. $ işareti gibi PHP için özel anlamı olan işaretlerin anlamlandırılmasını önlemek ve bu işaretleri düz metin saymasını sağlamak için bu işaretlerin önüne ters-bölü işareti koyarız. Buna o karakteri kurtarma veya ESCaping denir. PHP’nin anlamlı işaretleri ve bunların ESCape-yazılışı şöyledir:
\’ Tek tırnak
\” Çift tırnak
\\ Ters-bölü
\$ Dolar işareti
\n Yeni Satır (New Line)
\r Satır Başı (Return)
\t Sekme (Tab) karakteri
Kimi zaman bir değişkene atadığımız değerin türünü değiştirmek gerekir. Bunu settype() fonksiyonu ile yaparız. Elimizde böyle bir imkan var diye, bir değişkenin alfanümerik (String) olan değerini sayıya çevirebileceğini sanmayın. PHP buna çok kızar! Şu örneği de tur_degistir.php adıyla kaydedelim:
<HTML>
<HEAD>
<TITLE>PHP’de Degisken Turleri</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>
<B>
<H2>
<?php
$degisken = 5.67890;
print(“Değişkenin değeri : “);
print “$degisken<br>”;
print(“Türü : “);
print gettype( $degisken ) ; //çift,ondalık/double
print “<br>”;
print “<br>”;
print “İlk değiştirme işlemi: Alfanümerik/String:<br>”;
settype( $degisken, string ); //alfanümerik/string
print “Değeri : “;
print “$degisken<br>”;
print(“Türü : “);
print gettype( $degisken ) ; //alfanümerik/string
print “<br>”;
print “<br>”;
print “İkinci değiştirme işlemi: Tamsayı/Integer:<br>”;
settype( $degisken, integer ); //Tamsayı/Integer
print “Değeri : “;
print “$degisken<br>”;
print(“Türü : “);
print gettype( $degisken ) ; //Tamsayı/Integer
print “<br>”;
print “<br>”;
print “Üçüncü değiştirme işlemi: Ondalık/Double:<br>”;
settype( $degisken, double ); //çift,ondalık/double
print “Değeri : “;
print “$degisken<br>”;
print(“Türü : “);
print gettype( $degisken ) ; //çift,ondalık/double
print “<br>”;
print “<br>”;
print “Dördüncü değiştirme işlemi: Mantıksal/Boolean:<br>”;
settype( $degisken, boolean ); // Mantıksal/Boolean
print “Değeri : “;
print “$degisken<br>”;
print(“Türü : “);
print gettype( $degisken ) ; // Mantıksal/Boolean
print “<br>”;
print “<br>”;
?>
</H2>
</B>
</BODY>
</HTML>
Bu programı çalıştırdığımızda, ilk atadığımız değerin ondalık/double olarak belirlendiğine dikkat edin. Bu değerin türünü alfanümerik/string olarak değiştirdiğimizde değişmediğini görüyoruz. Fakat tamsayı/integer’a çevirdiğimizde PHP değerin tamsayı bölümünü alıyor; ondalık-kesir bölümünü atıyor. Nitekim daha sonra değişkerin türünü yeniden ondalık yaptığımız halde, atılan bu bölüm geri gelmiyor. Son olarak değişkeni mantıksal ifade olarak değiştirdiğimizde, değerin doğru/true olduğunu anlıyoruz; değer olarak bize 1 dönüyor. PHP, sıfır dışındaki tüm değerleri doğru/true’ya çevirir; sıfır’ı ise yanlış/false olarak atar ve boş/null değer verir.
<php00010.tif>
Şu anda PHP’yi tam bilemediğimiz için nerede kullanılır kestiremiyoruz, ama diyelim ki burada olduğu gibi, değişkeni bir daha düzelmeyecek şekilde değişikliğe uğratmak istemeyebiliriz; fakat yine de değerinin türünü değiştirmek isteyebiliriz. Bunu da nerede kullanabiliriz, şu anda bilmiyoruz. Ama diyelim ki, böyle bir işlem yapmaya ihtiyacımız oldu! Hatırlıyor musunuz, biraz önce özel bir şekilde bir değişkene başka bir değişkenin adını değer olarak vererek, aslında bu değişkenin ilk değişkenin değerini almasını sağlamıştık. Burada da aynı tekniği kullanabiliriz. Bu kodu da tur_kopyala.php adıyla kaydedin:
<HTML>
<HEAD>
<TITLE>PHP’de Degisken Turleri Kopyalama (Casting)</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>
<B>
<H2>
<?php
$degisken = 3.1418;
print(“Değişkenin değeri : “);
print “$degisken<br>”;
print(“Türü : “);
print gettype( $degisken ) ; //çift,ondalık/double
print “<br>”;
print “<br>”;
print “İlk kopyalama işlemi: Alfanümerik/String:<br>”;
$kopya_degisken = ( string ) $degisken; //alfanümerik/string
print “Değeri : “;
print “$kopya_degisken<br>”;
print(“Türü : “);
print gettype( $kopya_degisken ) ; //alfanümerik/string
print “<br>”;
print “<br>”;
print “İkinci kopyalama işlemi: Tamsayı/Integer:<br>”;
$kopya_degisken = ( integer ) $degisken; //Tamsayı/Integer
print “Değeri : “;
print “$kopya_degisken<br>”;
print(“Türü : “);
print gettype( $kopya_degisken ) ; //Tamsayı/Integer
print “<br>”;
print “<br>”;
print “Üçüncü değiştirme işlemi: Ondalık/Double:<br>”;
$kopya_degisken = ( double ) $degisken; //çift,ondalık/double
print “Değeri : “;
print “$kopya_degisken<br>”;
print(“Türü : “);
print gettype( $kopya_degisken ) ; //çift,ondalık/double
print “<br>”;
print “<br>”;
print “Dördüncü kopyalama işlemi: Mantıksal/Boolean:<br>”;
$kopya_degisken = ( boolean ) $degisken; // Mantıksal/Boolean
print “Değeri : “;
print “$kopya_degisken<br>”;
print(“Türü : “);
print gettype( $kopya_degisken ) ; // Mantıksal/Boolean
print “<br>”;
print “<br>”;
?>
</H2>
</B>
</BODY>
</HTML>
Bu programın can alıcı noktası örneğin “$kopya_degisken = ( boolean ) $degisken;” şeklindeki komut; burada $kopya_degisken adlı değişkene $degisken adlı değişkenin değerini (eşittir işareti ile) kazandırırken, arada yeni değişkenin kazanmasını istediğimiz türün adını parantez içinde yazıyoruz. Burada gerçekte, $degisken adlı değişkenin değerine hiç bir şey olmuyor. Bu programı çalıştırırsanız, ilk değerin ontalık kısmının önceki örnekte olduğu gibi değişim işlemi sonunda tamamen yok olmadığını görebilirsiniz.
<php00011.tif>
$degisken adlı değişkenin değeri değişmeden durduğu için üçüncü adımda yıptığımız ondalık tür olarak kopyalama sonucu yeni değişkenin değeri yine kesiri ile karşımıza çıkıyor.
php fonksiyon
Fonksiyon
PHP’nin gettype() ve print() gibi, kendi içinde bulunan kullanılmaya hazır bir çok fonksiyonu vardır. Daha sonra kendi fonksiyonlarımızı yazmanın yollarını da göreceğiz. Programcılık dilinde ister dile ait olsun, ister kendimiz yazmış olalım, bir fonksiyonu kullanmaya “fonksiyon çağırma” denir. Fonksiyonlar da fonksiyon çağırabilirler. Çağrılan bir fonksiyon ya kendisinden beklenen işi yapar, ya da kendisini çağıran işleme veya fonksiyonu bir değer sunar. Buna fonksiyondan dönen değer denir.
Şimdi, bir PHP programı yazalım, bir takım değişkenlere değerler atayalım ve bunların türlerini PHP’ye soralım. Bir düzyazı programı ile şu metni yazın ve turler.php adıyla kaydedin:
<HTML>
<HEAD>
<TITLE>PHP’de Degisken Turleri</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>
<B>
<H2>
<?php
$sayi = 5;
print(“Birinci değişkenin adı: \$sayi<br>”);
print(“Değeri : “);
print “$sayi<br>”;
print(“Türü : “);
print gettype( $sayi ) ; //tamsayi/integer
print “<br>”;
print “<br>”;
$alfanumerik = “Reşit”;
print “İkinci değişkenin adı: \$alfanumerik<br>”;
print “Değeri : “;
print “$alfanumerik<br>”;
print(“Türü : “);
print gettype( $alfanumerik ) ; //alfanümerik/string
print “<br>”;
print “<br>”;
$ondalik = 5.1234;
print “Üçüncü değişkenin adı: \$ondalik<br>”;
print “Değeri : “;
print “$ondalik<br>”;
print(“Türü : “);
print gettype( $ondalik ) ; //çift,ondalık/double
print “<br>”;
print “<br>”;
$mantiksal = true;
print “Üçüncü değişkenin adı: \$mantiksal<br>”;
print “Değeri : “;
print “$mantiksal<br>”;
print(“Türü : “);
print gettype( $mantiksal ) ; //mantıksal/boolean
print “<br>”;
print “<br>”;
?>
</H2>
</B>
</BODY>
</HTML>
Bu programı çalıştığımızda karşımıza şöyle bir görüntünün gelmesi gerekir:
<php00009.tif>
Burada mantıksal (boolean) değer olarak doğru anlamına true değeri atadığımız halde, PHP’nin bu değişkenin değeri olarak 1′i gösterdiğine dikkat edin. PHP’de bir fonksiyon, elde ettiği değer doğru ise sonuç olarak 1 değerini verir. (Yanlış/false değerinin neye çevrildiğini bulabilir misiniz?)
php veri türleri
PHP, değişkenlere, tuttukları değere göre farklı bellek alanı tahsis eder; bu bakımdan verilerimizin türü etkin bir programcılık açısından önem taşır. Ayrıca PHP, diğer bütün programlama dilleri gibi belirli veri türleri ile belirli işlemleri yapar veya yapamaz. Örneğin, ancak iki sayı arasında aritmedik toplama yapılabilir. İki metin tutan değişken aritmetik olarak toplanamaz; ancak içerdikleri değerler ardarda eklenebilir. Ne var ki, PHP sizin aritmetik toplama mı, yoksa ardarda ekleme mi yapmak istediğinizi bilmek durumunda değildir. (PHP’ye ‘muazzam dil’ dedik; içinde yapay zekâ var demedik!) Dolayısyla değerleri 5 ile 6 olan iki değişkeni topladığınız zaman ortaya 11 yerine 56 çıkarsa, kabahati PHP’de değil, değişkenlere veri atayan kişide (büyük bir ihtimalle kendinizde) aramalısınız.
PHP açısından dünyada altı tür değer vardır:
Tamsayı (Integer): 5,124, 9834 gibi
Çift (Double): 3,567 gibi
Alfanümerik (String): “Reşit” gibi
Mantıksal (Boolean): doğru (true)/yanlış (false) gibi
Nesne (Object)
Dizi (Array)
Bazı uzmanlara göre, gerçekte PHP’de mantıksal (boolean) değişken türü yoktur. B kanının sebebi, PHP’nin true (doğru) ya da false (yanlış) olarak atadığımız değerleri 1 ve boş/null değerlere çevirmesi, mantıksal olarak sorgulandığında 0 dışındaki tam ve ondalık değişkenleri TRUE, 0′ı FALSE sayması, ve boş alfanümerik değişkenleri FALSE, dolu alfanümerik değişkenleri ise TRUE olarak değerlendirmesidir. Ancak daha sonra gereceğimiz gibi PHP, Mantıksal/Boolean adında bir değişken değiştirme fonksiyonuna sahiptir ve bu tür değişkenlerin türü sorulduğunda “boolean” karşılığını verir.
Değişkenlere atadığımız değerlerinin türlerini genellikle biliriz; ama yüzlerce değişkenle uğraştığımız bir Web programında değişken türünü unutmak çok kolaydır. Kimi zaman da değişkenlere program yoluyla değer atarız; başka bir deyişle programımız bazı değişkenleri kendisi oluşturabilir, ve bunlara kendisi değer atayabilir. Bu tür program yoluyla atanan değerlerin de türünde kuşkuya kapıldığımız anlar olabilir. Bir değişkenin değerinin türü hakkında kuşkunuz varsa, en emin yol bunu PHP’nin kendisine sormaktır. Bu sorgulamayı gettype() fonksiyonu ile yaparız.
php yapı taşları
PHP’nin Yapı Taşları
PHP, bir programlama dili olarak, değişkenler, değişkenlerin değerleriyle bir işlem yapmayı sağlayan işlemciler, işlemcilerle oluşturulan deyimler ve nihayet bunların tümünü toplu olarak kullanmamızı sağlayan işlevlere (fonksiyonlara) sahiptir. PHP, nesne-yönelimli (object-oriented) bir dil olduğu için, nesne oluşturma imkanına ve bunların kullanılmasını sağlayan metodlara da sahiptir. Bütün bu imkanları kullanarak, PHP ile bir veritabanından veri alarak, bunları HTML etiketlerinin değerleri olarak kullanabiliriz; Web sitemizi ziyaret eden kişilerden bilgi alabiliriz, bu bilgilerle işlemler yapabiliriz. PHP’nin çeşitli komutlarını, deyimlerini ve fonksiyonlarını kullanarak, programımızın çalıştığı Web sunucusunun bulunduğu bilgisayara da çeşitli dosya işlemleri yaptırabiliriz.
Şimdi belki PHP’yi durdurmayı hiç düşünmüyorsunuz; ama ilerde bir fonksiyonun vereceği sonucun bütün programın durdurulmasını gerektiği zamanlar olabilir. PHP’nin resmî el kitabına bile ilk baskısında konulması unutulmuş olan programı durdurma komutu, exit kelimesidir; hiç bir parametre almadan çalışır.
Bu tür karmaşık uygulamalara geçebilmek için önce, PHP dilinin unsurlarını biraz yakından inceleyelim.
Programcılıkta işlemlerimizi değişkenlerle yaparız. Değişkeni bir kap gibi düşünebilirsiniz. Sözgelimi “Gün,” değişkenin adı ise bu değişkenin değeri Pazar, Pazartesi, Salı, vd., olabilir. Her değişken, türüne göre, ya bir ya da daha fazla değer tutar. Adından da anlaşılacağı gibi değişkenin değeri değişir! Bu değişikliği biz yapabiliriz; programın kendisi yapabilir.
PHP’de de, bir çok başka bilgisayar programlama dilinde olduğu gibi değişkenlerin içine bir değer konmadan önce tanımlanması mümkündür; fakat gerekli değildir. Değişkenleri adının önüne $ işareti koyarak tanımlarız:
$adi;
$soyadi;
$123;
$sevdigiRenk;
Değişkenler, harf, rakam veya alt çizgi (_) ile başlayabilirler; bu karakterleri içerebilirler; ama içinde boşluk veya diğer işaretler bulunamaz. PHP değişkenleri her türlü değişken tutabilirler: bir değişkenin adının yazılış şekli onun tutabileceği değerin niteliğini belirlemez. Dolayısıyla, “$adi” değişkenin değeri “Reşit” da olabilir, “1255″ de olabilir.
PHP’de genellikle değişkenleri değerini atayarak belirleriz:
$adi = “Reşit”;
$soyadi = “Gülen”;
$123 = 123;
$sevdigiRenk = “yeşil”;
Değişkenler, kullanıldıkları işleme, taşıdıkları değeri verirler:
print $adi;
komutu, eğer değeri “Reşit” ise “Browser penceresine “Reşit” kelimesini yazdırır.
PHP’de özel bir değişkene değişken adı olarak kullanılacak değerleri de atayabiliriz:
$adi = “Reşit”;
$degisken = “adi”;
print $$degisken;
Burada Browser penceresine yine “Reşit” kelimesi yazılacaktır; çünkü PHP $degisken adlı değişkenin “adi” adlı değişkeni tuttuğunu bilecek ve iki Dolar işaretini görünce, $degisken’in değerini değil, onun tuttuğu değişkenin değerini yazacaktır. Bu, size şu anda karışık görünebilir. Daha sonra döngüleri gördüğümüzde bu tekniği bir satırlık kod ile yüzlerce değeri yazdırmakta kullanacağız. Bu teknik şöyle de kullanılabilir:
$degisken = “adi”;
$$degisken = “Reşit”;
print “$adi”;
print $$degisken;
print “${$degisken}”;
print “${‘adi’}”;
Buradaki dört “print” komutu da Browser’a “Reşit” kelimesini yazdıracaktır.
PHP’de bir değişkenin tuttuğu değer, bir başka değişkene atanabilir. Bu ya duragan, ya da dinamik olarak yapılır. Duragan yöntemde:
$birinci_degisken = “Nurcan”;
$ikinci_degisken = $birinci_degisken;
$birinci_degisken = “Tülay”;
print $ikinci_degisken;
Buradaki “print” komutu Browser penceresine “Reşit” kelimesini yazdıracaktır. İki değişken arasındaki değer alış-verişi birinci değişkenin tuttuğu değeri değiştirmeden önce olduğu için, ikinci değişken birinci değişkenin ilk değerini almış oldu. Fakat kimi zaman iki değişken arasındaki değer alış-verişi sürekli (dinamik) olsun isteriz. PHP, buna, ilk atama sırasında & işareti kullanırsak izin verir:
$birinci_degisken = “Nurcan”;
$ikinci_degisken = &$birinci_degisken;
$birinci_degisken = “Tülay”;
print $ikinci_degisken;
Buradaki “print” komutu ise Browser penceresine “Tülay” kelimesini yazdıracaktır. Çünkü iki değişken arasındaki değer alış-verişi birinci değişkenin tuttuğu değeri değiştirmeden önce halde, ikinci değişkene birinci değişkenin değerini dinamik olarak atamış olduk. Atama işlemi sırasında & işareti kullandığımız için, birinci değişkenin değeri değiştiğinde ikinci değişkenin de değeri değişecektir.
