Çerezler
Bu web sitesi sizlere daha iyi hizmet verebilmek için çerezleri kullanır.
PHP geliştiricileri için harici kaynaklarla etkileşim, genellikle dosya sisteminden veri okuma, ağ istekleri yapma veya özel protokollere erişim gibi işlemleri içerir. Bu tür işlemlerin davranışını detaylı bir şekilde kontrol etmek, özellikle ağ isteklerinde zaman aşımı, kimlik doğrulama, vekil sunucu ayarları gibi özelleştirmeler yapmak kritik öneme sahiptir. PHP'nin bağlam (context) mekanizması, bu etkileşimleri yapılandırmak için güçlü ve esnek bir yol sunar. Bağlamlar, bir akış (stream) işlemi sırasında kullanılacak protokole özgü seçenekleri ve kullanıcı tanımlı bağımsız değişkenleri (parameters) bir araya getiren bir kapsayıcı görevi görür. Bu makale, PHP'de bağlam seçeneklerinin ve bağımsız değişkenlerinin nasıl tanımlandığını ve kullanıldığını detaylı bir şekilde inceleyecektir.
PHP'de bir bağlam oluşturmak ve yapılandırmak için başlıca iki fonksiyon kullanılır: stream_context_create() ve stream_context_set_option(). Bağımsız değişkenleri (parameters) ayarlamak için ise stream_context_set_params() fonksiyonu mevcuttur.
Bağlam Oluşturma:
$context = stream_context_create(
array $options = [],
array $params = []
);Seçenek Ayarlama:
bool stream_context_set_option(
resource $context,
string $wrapper,
string $option,
mixed $value
);
// Alternatif olarak, stream_context_create() sırasında da ayarlanabilir:
// $context = stream_context_create([
// 'wrapper' => [
// 'option' => 'value'
// ]
// ]);Bağımsız Değişken Ayarlama:
bool stream_context_set_params(
resource $context,
array $params
);PHP'deki akış bağlamları, belirli bir akış işlemi sırasında davranışını değiştirmek için kullanılan anahtar-değer çiftlerinden oluşan koleksiyonlardır.
stream_context_create() fonksiyonu, yeni bir akış bağlamı kaynağı (resource) döndürür. Bu fonksiyon, isteğe bağlı olarak iki dizi parametresi alır:
$options: Bu dizi, çeşitli akış sarmalayıcıları (wrapper) için protokole özgü seçenekleri içerir. Yapısı ['wrapper_adı' => ['seçenek_adı' => 'değer']] şeklindedir.
$params: Bu dizi, bağlam için kullanıcı tanımlı bağımsız değişkenleri içerir. Genellikle bir bağlamın yaşam döngüsü boyunca bir akışa özel veri veya geri çağırma fonksiyonları (callback functions) eklemek için kullanılır.
Seçenekler (Options):
Seçenekler, belirli bir sarmalayıcının (wrapper) davranışını özelleştirmek için kullanılır. Örneğin, http:// sarmalayıcısı için zaman aşımı (timeout), kullanıcı aracısı (user agent) veya HTTP başlıkları gibi ayarlar yapılabilir. Her sarmalayıcının desteklediği seçenekler farklıdır. Yaygın olarak kullanılan bazı sarmalayıcılar ve seçenek kategorileri şunlardır:
http / https: method, header, user_agent, timeout, proxy, follow_location, content vb.
ftp: overwrite, resume_pos, timeout vb.
file: throw_exceptions (PHP 8.0+)
ssl: verify_peer, cafile, local_cert, passphrase vb.
stream_context_set_option() fonksiyonu, mevcut bir bağlama tek bir seçenek eklemek veya değiştirmek için kullanılır. Parametreleri şunlardır:
$context: Seçeneğin ekleneceği veya değiştirileceği bağlam kaynağı.
$wrapper: Seçeneğin ait olduğu akış sarmalayıcısının adı (örneğin, 'http' veya 'ssl').
$option: Ayarlanacak seçeneğin adı (örneğin, 'timeout' veya 'method').
$value: Seçeneğin değeri.
PHP 8 ile tanıtılan öznitelikler (attributes), kodunuza yapısal, meta verisel bilgiler eklemenin modern ve deklaratif bir yolunu sunar. Bu özellik, docblock yorumlarının sunduğu sınırlı yeteneklerin ötesine geçerek, sınıflara, yöntemlere, özelliklere, fonksiyonlara, sabitlere ve parametrelere doğrudan programatik meta veriler eklemenize olanak tanır. PHP çekirdeği tarafından sunulan ön tanımlı öznitelikler, geliştiricilere sıkça karşılaşılan senaryolarda kodlarını daha net, güvenli ve yönetilebilir hale getirme imkanı sağlar. Bu makale, PHP'de ön tanımlı özniteliklerin temel kullanımını ve pratik uygulamalarını detaylandıracaktır.
Ön tanımlı öznitelikler, hedeflenen kod öğesinin hemen üzerine, #[ ile başlayıp ] ile biten bir yapı içinde yerleştirilir. Her öznitelik, bir sınıf gibi davranır ve isteğe bağlı olarak parametreler alabilir. Birden fazla öznitelik aynı öğeye uygulanabilir ve bunlar virgül ile ayrılarak aynı #[...] bloğunda veya ayrı bloklarda belirtilebilir.
Genel sözdizimi aşağıdaki gibidir:
Sözdiziminde yer alan ana bileşenler ve anlamları şunlardır:
#[ ve ]: Öznitelik bloğunu tanımlayan sınırlayıcılardır. Tüm öznitelikler bu işaretler arasına yerleştirilmelidir.
AttributeAdi: Uygulanacak özniteliğin adıdır. Bu isim, genellikle PHP çekirdeği veya kütüphaneler tarafından sağlanan ön tanımlı bir öznitelik sınıfının adıdır. Örneğin, #[Deprecated] veya #[Override].
(parametre1: deger1, parametre2: deger2): Bazı öznitelikler, davranışlarını özelleştirmek için parametreler alabilir. Bu parametreler, öznitelik sınıfının kurucusuna (constructor) geçirilen argümanlardır. Parametreler adlandırılmış argümanlar olarak veya konumlarına göre verilebilir. Ön tanımlı özniteliklerde genellikle adlandırılmış argümanlar tercih edilir.
Hedef Konum: Öznitelikler bir sınıfın, bir sınıf özelliğinin (property), bir sınıf metodunun, bir fonksiyonun, bir sınıf sabitinin veya bir metodun/fonksiyonun parametresinin hemen üzerine yerleştirilmelidir.
PHP'nin çekirdeği tarafından sunulan bazı önemli ön tanımlı öznitelikler şunlardır:
#[AllowDynamicProperties]: PHP 8.2'den itibaren dinamik özelliklerin bildirilmemiş sınıflarda kullanılması önerilmez ve ileride hata fırlatabilir. Bu öznitelik, bir sınıfa dinamik özellikler eklenmesine izin verildiğini açıkça belirtir ve bir uyarının (DeprecationWarning) önüne geçer.
#[Override]: PHP 8.3 ile tanıtılan bu öznitelik, bir metodun üst sınıftaki veya uyguladığı arayüzdeki bir metodu geçersiz kıldığını (override ettiğini) açıkça işaretler. Eğer üst sınıfta veya arayüzde böyle bir metod yoksa, çalışma zamanında bir hata fırlatılır. Bu, yazım hatalarını veya refactoring sonrası oluşabilecek hataları engellemeye yardımcı olur.
#[Deprecated]: Bu öznitelik, bir kod öğesinin (sınıf, metot, özellik vb.) kullanımının artık önerilmediğini ve gelecekte kaldırılabileceğini belirtir. Bu, geliştiricilere eski API'leri kullanmaktan kaçınmaları için bir uyarı sağlar.
Örnek 1: #[AllowDynamicProperties] Kullanımı
Bu örnek, bir sınıfa dinamik özellikler eklenmesine izin vermek için #[AllowDynamicProperties] özniteliğinin nasıl kullanılacağını göstermektedir. PHP 8.2 ve sonraki sürümlerde, bu öznitelik olmadan dinamik özellikler kullanıldığında bir öneri (deprecate) uyarısı alırsınız.
$value) {
$this->$key = $value; // Dinamik özellik ataması
}
}
public function getAyari(string $key)
{
return $this->$key ?? null;
}
}
$ayarlar = new Ayarlar(['veritabani' => 'mysql', 'host' => 'localhost']);
echo $ayarlar->getAyari('veritabani'); // Çıktı: mysql
// Dinamik olarak yeni bir özellik eklemek
$ayarlar->cache = true;
echo "
";
echo "Önbellek aktif mi? " . ($ayarlar->cache ? "Evet" : "Hayır");
Yukarıdaki kodda, Ayarlar sınıfı #[AllowDynamicProperties] ile işaretlendiği için, constructor içinde döngü ile veya sonradan dışarıdan dinamik özellikler eklenmesi herhangi bir uyarıya neden olmaz.
Örnek 2: #[Override] Kullanımı
Bu örnek, bir alt sınıfın üst sınıftaki bir metodu doğru bir şekilde geçersiz kıldığını doğrulamak için #[Override] özniteliğinin nasıl kullanılacağını göstermektedir.
ad = $ad;
$this->fiyat = $fiyat;
}
#[Override]
public function getFiyat(): float
{
return $this->fiyat;
}
#[Override]
public function getAd(): string
{
return $this->ad;
}
// Eğer burada yanlışlıkla `getFiyat` yerine `getFiyatX` yazsaydık
// ve #[Override] kullansaydık, PHP çalışma zamanında hata verirdi.
// #[Override]
// public function getFiyatX(): float
// {
// return $this->fiyat;
// }
}
$kitap = new Kitap("PHP Başlangıç Rehberi", 49.99);
echo "Ürün Adı: " . $kitap->getAd() . "
";
echo "Fiyat: " . $kitap->getFiyat();
Yukarıdaki örnekte, Kitap sınıfındaki getFiyat() ve getAd() metotları #[Override] ile işaretlenmiştir. Bu, bu metotların TemelUrun sınıfındaki karşılık gelen metotları geçersiz kıldığını açıkça belirtir. Eğer TemelUrun sınıfında böyle bir metot olmasaydı veya yazım hatası yapılsaydı, PHP bir hata fırlatırdı.
Örnek 3: #[Deprecated] Kullanımı
Bu örnek, bir metodun artık kullanılmaması gerektiğini belirtmek için #[Deprecated] özniteliğinin nasıl kullanılacağını gösterir.
eskiIslem() . "
"; // Bu satır bir "Deprecated" uyarısı verir
echo $obj->yeniIslem();
eskiIslem() metodunu çağırdığınızda, PHP bir "Deprecated" uyarısı verir. Bu uyarı, geliştiricilere bu metodun kullanımından kaçınmaları ve yerine yeniIslem() metodunu kullanmaları gerektiğini bildirir. reason parametresi, uyarının içeriğini özelleştirmek için kullanılır.
Versiyon Uyumluluğu: Öznitelikler PHP 8.0 ve sonraki sürümlerde mevcuttur. #[Override] ise PHP 8.3 ile eklenmiştir. Kullanacağınız özniteliklerin PHP versiyonunuza uygun olduğundan emin olun.
Okunabilirlik ve Bakım: Öznitelikler, kodun amacını ve davranışını daha açık bir şekilde ifade ederek okunabilirliği artırır ve gelecekteki bakımı kolaylaştırır.
Hata Yakalama: #[Override] gibi öznitelikler, derleme zamanında (veya PHP'nin çalışma zamanı öncesi kontrolünde) hataları yakalayarak geliştirme sürecinde potansiyel sorunları erkenden tespit etmenizi sağlar.
Performans Etkisi: Özniteliklerin doğrudan çalışma zamanı performansına önemli bir etkisi yoktur. Genellikle yansıma (reflection) API'leri aracılığıyla okunur ve işlenirler.
Kendi Özniteliklerinizi Tanımlama: PHP, ön tanımlı özniteliklerin yanı sıra kendi özel özniteliklerinizi tanımlamanıza da olanak tanır. Bu, framework'ler ve kütüphaneler için güçlü bir meta programlama aracıdır.
Nesne yönelimli programlama (OOP) prensipleri, modern yazılım geliştirmede kodun yapısını, okunabilirliğini ve sürdürülebilirliğini sağlamak için kritik öneme sahiptir. PHP, bu prensipleri desteklemek adına arayüzler (interfaces) ve soyut sınıflar (abstract classes) gibi güçlü yapılar sunar. Bu yapılar, sınıflar arasında belirli davranış sözleşmeleri tanımlayarak veya ortak bir temel sağlayarak esnek ve genişletilebilir sistemler oluşturulmasına olanak tanır. Bu makale, PHP'deki arayüzlerin ve soyut sınıfların detaylı kullanımını, sözdizimini ve pratik örneklerini ele alacaktır.
PHP'de arayüzler ve soyut sınıflar, belirli anahtar kelimeler kullanılarak tanımlanır ve diğer sınıflar tarafından uygulanır veya miras alınır. Aşağıda temel sözdizimleri gösterilmektedir.
ozellik = $ozellik;
}
// Soyut metot: Gövdesi yoktur, alt sınıflar tarafından uygulanmalıdır.
abstract public function soyutMetot(): string;
// Somut metot: Gövdesi vardır, alt sınıflar tarafından miras alınır veya geçersiz kılınabilir.
public function somutMetot(): string {
return "Somut metot çalıştı: " . $this->ozellik;
}
}
// Arayüz Uygulayan Sınıf
class SomutSinifA implements ArayuzAdi {
public function metotBir(string $parametre): bool {
// Metot uygulamasını buraya yazın
return true;
}
public function metotIki(): void {
// Metot uygulamasını buraya yazın
}
}
// Soyut Sınıfı Miras Alan Sınıf
class SomutSinifB extends SoyutSinifAdi {
public function soyutMetot(): string {
return "Soyut metot SomutSinifB tarafından uygulandı: " . $this->ozellik;
}
}
?>
Arayüzler ve soyut sınıflar, farklı senaryolar için tasarlanmış olsalar da, her ikisi de soyutlama ve polimorfizm prensiplerini destekler.
Bir arayüz, bir sınıfın sahip olması gereken metotları tanımlayan bir "sözleşme" görevi görür. Arayüzler, bir sınıfın dış dünyaya hangi davranışları sergileyeceğini belirtir, ancak bu davranışların nasıl uygulanacağını belirtmez.
Tanım: Bir arayüz interface anahtar kelimesiyle tanımlanır. İçerisinde yalnızca metot imzaları ve sabitler bulunabilir.
Metotlar: Arayüzdeki tüm metotlar otomatik olarak public ve soyuttur (yani gövdeleri yoktur). Metot imzaları, parametre tiplerini ve dönüş tiplerini (PHP 7.0 ve sonrası) içerebilir.
Özellikler: Arayüzler herhangi bir özellik (member variable) tanımlayamaz.
Sabitler: Arayüzler sabitler tanımlayabilir. Bu sabitlere ArayuzAdi::SABIT_ADI şeklinde erişilebilir.
Uygulama: Bir sınıf, bir arayüzü implements anahtar kelimesiyle uygular. Bir sınıf birden fazla arayüzü uygulayabilir (örneğin: class MyClass implements InterfaceA, InterfaceB).
Zorunluluk: Bir arayüzü uygulayan sınıf, arayüzdeki tüm metotları belirtilen imzalarla (public olarak) uygulamak zorundadır. Aksi takdirde bir fatal hata oluşur.
Soyut sınıflar, bir veya daha fazla soyut metot içerebilen veya içermeyen, doğrudan örneği oluşturulamayan sınıflardır. Genellikle, bir grup ilgili sınıf için ortak bir temel (base class) sağlamak amacıyla kullanılırlar.
Tanım: Bir soyut sınıf abstract class anahtar kelimesiyle tanımlanır.
Örneklenme: Soyut sınıfların doğrudan bir örneği (objesi) oluşturulamaz. Yalnızca alt sınıfları (concrete classes) örneklenebilir.
Metotlar: Soyut sınıflar hem soyut metotlar (abstract public function metotAdi();) hem de somut metotlar (gövdesi olan metotlar) içerebilir. Soyut metotların gövdesi yoktur ve alt sınıflar tarafından uygulanması zorunludur. Somut metotlar ise alt sınıflar tarafından miras alınır ve isteğe bağlı olarak geçersiz kılınabilir.
Erişim Belirleyiciler: Soyut metotlar public veya protected olabilir ancak private olamaz. Alt sınıflar soyut metotları uygularken aynı veya daha az kısıtlayıcı bir erişim belirleyici kullanamazlar (yani protected soyut metot public olarak uygulanabilir ama private olarak uygulanamaz).
Özellikler: Soyut sınıflar özellikler (member variables) tanımlayabilir. Bu özellikler public, protected veya private olabilir.
Kalıtım: Bir sınıf, bir soyut sınıfı extends anahtar kelimesiyle miras alır. PHP tekli kalıtımı desteklediği için bir sınıf yalnızca bir soyut sınıfı miras alabilir.
Zorunluluk: Soyut bir sınıfı miras alan alt sınıf, soyut sınıftaki tüm soyut metotları uygulamak zorundadır. Aksi takdirde, alt sınıfın kendisi de soyut olarak tanımlanmalıdır.
Aşağıdaki örnekler, arayüzlerin ve soyut sınıfların gerçek dünya senaryolarında nasıl kullanılabileceğini göstermektedir.
Farklı loglama mekanizmalarını (dosyaya, veritabanına, konsola) destekleyen bir sistem düşünelim. Tüm loglama sınıflarının aynı log() metoduna sahip olmasını bir arayüz ile sağlayabiliriz.
filePath = $filePath;
}
public function log(string $message): void {
file_put_contents($this->filePath, date('Y-m-d H:i:s') . " - " . $message . PHP_EOL, FILE_APPEND);
echo "Dosyaya loglandı: " . $message . "
";
}
}
class DatabaseLogger implements Logger {
public function log(string $message): void {
// Veritabanına loglama işlemleri burada yapılır
echo "Veritabanına loglandı: " . $message . "
";
}
}
class ConsoleLogger implements Logger {
public function log(string $message): void {
echo "Konsola loglandı: " . $message . "
";
}
}
// Loglama işlemini gerçekleştiren bir fonksiyon
function processLog(Logger $logger, string $message): void {
$logger->log($message);
}
// Kullanım
$fileLogger = new FileLogger('application.log');
$dbLogger = new DatabaseLogger();
$consoleLogger = new ConsoleLogger();
processLog($fileLogger, "Uygulama başlatıldı.");
processLog($dbLogger, "Kullanıcı girişi başarılı.");
processLog($consoleLogger, "Hata oluştu.");
// Çıktı:
// Dosyaya loglandı: Uygulama başlatıldı.
// Veritabanına loglandı: Kullanıcı girişi başarılı.
// Konsola loglandı: Hata oluştu.
?>
Bu örnekte, Logger arayüzü, loglama yeteneğine sahip tüm sınıfların log() metodunu içermesi gerektiğini garanti eder. Bu sayede, processLog() fonksiyonu herhangi bir Logger tipindeki objeyi kabul edebilir, bu da esneklik ve kod tekrarı önleme sağlar.
Bir e-ticaret uygulamasında farklı ödeme geçitleri (Kredi Kartı, PayPal, Havale) olabilir. Bu geçitlerin hepsinin ortak bazı işlevleri (örneğin işlem ücreti hesaplama) ve kendine özgü işlevleri (ödeme onayı) bulunur. Ortak işlevleri soyut bir sınıfta toplayabiliriz.
transactionFeeRate = $rate;
}
// Ortak somut metot
public function calculateFee(float $amount): float {
return $amount * $this->transactionFeeRate;
}
// Soyut metot: Her alt sınıfın kendi ödeme işlemini tanımlaması gerekir
abstract public function processPayment(float $amount): bool;
// Soyut metot: Her alt sınıfın kendi geri ödeme işlemini tanımlaması gerekir
abstract public function refundPayment(string $transactionId): bool;
}
class CreditCardGateway extends PaymentGateway {
public function __construct() {
parent::__construct(0.025); // %2.5 işlem ücreti
}
public function processPayment(float $amount): bool {
echo "Kredi kartı ile " . $amount . " TL ödeme işlemi başlatıldı. Ücret: " . $this->calculateFee($amount) . " TL.
";
// Kredi kartı API'si ile ödeme mantığı
return true;
}
public function refundPayment(string $transactionId): bool {
echo "Kredi kartı işlemi " . $transactionId . " için geri ödeme yapıldı.
";
// Kredi kartı API'si ile geri ödeme mantığı
return true;
}
}
class PayPalGateway extends PaymentGateway {
public function __construct() {
parent::__construct(0.03); // %3 işlem ücreti
}
public function processPayment(float $amount): bool {
echo "PayPal ile " . $amount . " TL ödeme işlemi başlatıldı. Ücret: " . $this->calculateFee($amount) . " TL.
";
// PayPal API'si ile ödeme mantığı
return true;
}
public function refundPayment(string $transactionId): bool {
echo "PayPal işlemi " . $transactionId . " için geri ödeme yapıldı.
";
// PayPal API'si ile geri ödeme mantığı
return true;
}
}
// Kullanım
$creditCard = new CreditCardGateway();
$paypal = new PayPalGateway();
$creditCard->processPayment(100.00);
$paypal->processPayment(250.00);
$creditCard->refundPayment("CC12345");
$paypal->refundPayment("PP67890");
// Çıktı:
// Kredi kartı ile 100 TL ödeme işlemi başlatıldı. Ücret: 2.5 TL.
// PayPal ile 250 TL ödeme işlemi başlatıldı. Ücret: 7.5 TL.
// Kredi kartı işlemi CC12345 için geri ödeme yapıldı.
// PayPal işlemi PP67890 için geri ödeme yapıldı.
?>
Burada PaymentGateway soyut sınıfı, tüm ödeme geçitleri için ortak olan calculateFee() metodunu ve her geçidin kendi içinde uygulaması gereken processPayment() ve refundPayment() soyut metotlarını tanımlar. Bu, kod tekrarını azaltır ve ödeme geçidi eklemeyi standartlaştırır.
Bir soyut sınıfın bir arayüzü uygulaması ve bu soyut sınıfı miras alan somut sınıfların arayüzdeki metotları uygulaması da mümkündür. Bu, hem bir sözleşme sağlamak hem de belirli bir varsayılan uygulama veya ortak davranış seti sunmak için güçlü bir kombinasyondur.
sender = $sender;
}
// Soyut metot: Arayüzden miras alınır ve alt sınıflar tarafından uygulanmalıdır
abstract public function send(string $recipient, string $message): bool;
// Ortak bir somut metot: Tüm bildirim sistemlerinde bulunabilir
public function getSender(): string {
return $this->sender;
}
}
// Somut sınıf: E-posta ile bildirim gönderen bir sistem
class EmailNotifier extends AbstractNotifier {
public function send(string $recipient, string $message): bool {
echo "E-posta gönderiliyor: Kimden: " . $this->getSender() . ", Kime: " . $recipient . ", Mesaj: '" . $message . "'
";
// Gerçek e-posta gönderme mantığı buraya gelir
return true;
}
}
// Somut sınıf: SMS ile bildirim gönderen bir sistem
class SmsNotifier extends AbstractNotifier {
public function send(string $recipient, string $message): bool {
echo "SMS gönderiliyor: Kimden: " . $this->getSender() . ", Kime: " . $recipient . ", Mesaj: '" . $message . "'
";
// Gerçek SMS gönderme mantığı buraya gelir
return true;
}
}
// Kullanım
$emailNotifier = new EmailNotifier("info@example.com");
$smsNotifier = new SmsNotifier("5551234567");
$emailNotifier->send("john.doe@example.com", "Hesabınız başarıyla oluşturuldu.");
$smsNotifier->send("5559876543", "Siparişiniz yola çıktı.");
// Çıktı:
// E-posta gönderiliyor: Kimden: info@example.com, Kime: john.doe@example.com, Mesaj: 'Hesabınız başarıyla oluşturuldu.'
// SMS gönderiliyor: Kimden: 5551234567, Kime: 5559876543, Mesaj: 'Siparişiniz yola çıktı.'
?>
Bu örnekte, Notifier arayüzü tüm bildirim sistemlerinin send() metoduna sahip olmasını sağlayan bir sözleşme sunar. AbstractNotifier soyut sınıfı ise bu arayüzü uygulayarak send() metodunu soyut bırakır, ancak tüm bildirim sistemleri için ortak bir gönderen özelliği ve getSender() metodu sağlar. EmailNotifier ve SmsNotifier sınıfları, AbstractNotifier'ı miras alarak hem Notifier arayüzünün gereksinimlerini yerine getirir hem de ortak getSender() metodunu kullanır.
Amaç Farkı: Arayüzler "ne yapılması gerektiğini" tanımlayan sözleşmelerdir. Soyut sınıflar ise "kim olduğunu" ve "neyin ortak olduğunu" tanımlayan kısmi uygulamalardır.
Çoklu Uygulama vs. Tekli Kalıtım: Bir sınıf birden fazla arayüzü uygulayabilir (implements InterfaceA, InterfaceB), bu PHP'de çoklu kalıtımı simüle etmenin bir yoludur. Ancak bir sınıf yalnızca bir soyut sınıfı miras alabilir (extends AbstractClass).
Metot Erişim Belirleyicileri: Arayüz metotları her zaman public olmak zorundadır. Soyut sınıf metotları ise public veya protected olabilir, ancak private olamaz.
Özellikler (Properties): Arayüzler özellik tanımlayamaz. Soyut sınıflar ise özellik tanımlayabilir ve bu özellikler public, protected veya private olabilir.
Sabitler: Hem arayüzler hem de soyut sınıflar sabitler tanımlayabilir.
Yapıcı Metotlar (Constructors): Soyut sınıflar yapıcı metotlara sahip olabilir. Arayüzler ise PHP 8.1 öncesinde yapıcı metot tanımlayamazdı. PHP 8.1 ve sonrası için arayüzler de yapıcı metot tanımlayabilir, ancak bu metotlar yine soyut olmak zorundadır.
Soyut Metotların Uygulanması: Bir soyut sınıfı miras alan veya bir arayüzü uygulayan somut sınıf, tüm soyut metotları veya arayüz metotlarını uygulamak zorundadır. Aksi takdirde, bu alt sınıfın da soyut olarak tanımlanması gerekir.
Kullanım Seçimi: Eğer sadece bir davranış sözleşmesi tanımlamak ve sınıflar arasında hiçbir ortak kod paylaşımı yoksa arayüz kullanın. Eğer sınıflar arasında ortak kod ve özellikler paylaşılıyorsa ve bu sınıfların aynı "tip" olduğunu belirtmek istiyorsanız soyut sınıf kullanın. Her ikisi de gerektiğinde birlikte kullanılabilir.
Modern yazılım geliştirmede, beklenmedik durumları ve hataları etkili bir şekilde yönetmek, uygulamanın sağlamlığı ve sürdürülebilirliği için kritik öneme sahiptir. PHP, bu tür durumları ele almak için güçlü bir istisna yönetimi mekanizması sunar. Bu mekanizma, programın normal akışını bozmadan, hata koşullarının yakalanmasını ve uygun şekilde işlenmesini sağlar. PHP'deki öntanımlı istisnalar, çeşitli hata senaryoları için standartlaştırılmış çözümler sunarak geliştiricilerin daha temiz, okunaklı ve bakımı kolay kod yazmasına yardımcı olur.
PHP'de istisnaları kullanmanın temel yapısı, bir kod bloğunu hata açısından izlemek için try, yakalanan istisnayı işlemek için catch ve isteğe bağlı olarak, try ve catch bloklarının yürütülmesinden sonra her zaman çalıştırılacak kodu tanımlamak için finally anahtar kelimelerinden oluşur.
İstisna yönetiminin temel bileşenleri ve öntanımlı istisna sınıfları şunlardır:
try Bloğu: İstisna fırlatma potansiyeli olan kod, bu bloğun içine yerleştirilir. Eğer bu blok içinde bir istisna fırlatılırsa, normal akış kesilir ve kontrol uygun catch bloğuna geçer.
catch Bloğu: Bir try bloğu içinde fırlatılan bir istisnayı yakalamak için kullanılır. catch anahtar kelimesi, parantez içinde yakalanacak istisna türünü (sınıfını) ve bu istisnayı temsil edecek bir değişkeni (genellikle $e) alır. PHP, istisna hiyerarşisinde fırlatılan istisnayla eşleşen ilk catch bloğunu çalıştırır. Genel Exception sınıfı en genel istisna türüdür ve tüm istisnaları yakalar. Daha spesifik istisnalar için, bu sınıfın alt sınıfları kullanılmalıdır.
finally Bloğu (PHP 5.5+): Bu blok içindeki kod, try ve catch bloklarının yürütülmesinden sonra her zaman çalışır, bir istisna fırlatılsa da fırlatılmasa da. Kaynakları serbest bırakmak veya temizlik işlemleri yapmak için idealdir.
throw Anahtar Kelimesi: Manuel olarak bir istisna fırlatmak için kullanılır. Bir istisna fırlatıldığında, programın normal akışı durur ve kontrol, fırlatılan istisnayı yakalamaya uygun bir catch bloğu arar.
Exception Sınıfı: PHP'deki tüm istisna sınıflarının temelidir. Kendi özel istisna sınıflarınızı oluştururken bu sınıftan türetebilirsiniz. Exception sınıfı; hata mesajı, hata kodu, dosya adı ve satır numarası gibi önemli bilgilere erişim sağlayan metotlara sahiptir.
Öntanımlı İstisna Sınıfları: PHP, çeşitli senaryolar için bir dizi öntanımlı istisna sınıfı sunar. Bunlar, Exception sınıfının alt sınıflarıdır ve belirli hata koşullarını daha spesifik olarak ele almanızı sağlar. Örnekler arasında şunlar bulunur:
InvalidArgumentException: Bir fonksiyona veya metoda geçersiz bir argüman iletildiğinde fırlatılır.
LengthException: Bir değerin uzunluğu uygun olmadığında fırlatılır (örn. bir string'in veya dizinin).
OutOfRangeException: İstenen değerin geçerli bir aralık dışında olduğunu belirtir.
RuntimeException: Çalışma zamanında ortaya çıkan hatalar için genel bir istisnadır. Diğer, daha spesifik RuntimeException alt sınıfları da mevcuttur (örn. BadFunctionCallException, BadMethodCallException).
TypeError: Bir fonksiyona veya metoda yanlış türde bir argüman iletildiğinde fırlatılır (PHP 7+).
Aşağıdaki örnekler, öntanımlı istisnaların PHP uygulamalarında nasıl kullanılabileceğini göstermektedir.
Örnek 1: Temel try-catch kullanımı
";
echo "10 / 0 = " . bol(10, 0) . "
"; // Bu satır bir istisna fırlatır
echo "Bu satır asla çalışmayacak.
";
} catch (InvalidArgumentException $e) {
echo "Bir hata yakalandı: " . $e->getMessage() . "
";
echo "Hata kodu: " . $e->getCode() . "
";
echo "Hata dosyası: " . $e->getFile() . " satır " . $e->getLine() . "
";
} finally {
echo "Bölme işlemi denemesi tamamlandı.
";
}
echo "Program devam ediyor.
";
?>Bu örnekte, bol fonksiyonu sıfıra bölme durumunda bir InvalidArgumentException fırlatır. try bloğu bu fonksiyonu çağırır ve istisna oluştuğunda kontrol catch bloğuna geçer. finally bloğu ise istisna fırlatılsa da fırlatılmasa da çalışır.
Örnek 2: Birden Fazla catch Bloğu ile Spesifik İstisnaları Yakalama
2) {
throw new OutOfRangeException("Mod değeri 0 ile 2 arasında olmalıdır.");
}
switch ($mod) {
case 0: return strtoupper($veri);
case 1: return strtolower($veri);
case 2: return strrev($veri);
}
return $veri; // Bu satıra asla ulaşılmamalı
}
try {
echo islemYap("Merhaba", 1) . "
";
echo islemYap("", 0) . "
"; // InvalidArgumentException fırlatır
echo islemYap("Dunya", 5) . "
"; // Bu satıra ulaşılamaz
} catch (InvalidArgumentException $e) {
echo "Geçersiz argüman hatası: " . $e->getMessage() . "
";
} catch (OutOfRangeException $e) {
echo "Aralık dışı hata: " . $e->getMessage() . "
";
} catch (Exception $e) { // Tüm diğer istisnaları yakalar
echo "Genel bir hata oluştu: " . $e->getMessage() . "
";
} finally {
echo "İşlem denemesi sona erdi.
";
}
?>Bu örnek, farklı istisna türlerini yakalamak için birden fazla catch bloğunun nasıl kullanılacağını gösterir. PHP, istisna hiyerarşisinde en spesifik olandan en genele doğru sıralama yapılmasını önerir. Bu şekilde, önce InvalidArgumentException ve OutOfRangeException gibi özel durumlar yakalanır, ardından Exception ile diğer tüm istisnalar ele alınır.
Spesifik İstisnaları Yakalayın: Mümkün olduğunca spesifik istisna sınıflarını yakalayın (örn. InvalidArgumentException yerine Exception kullanmak yerine). Bu, hata koşullarını daha doğru bir şekilde tanımlamanıza ve işlemenize olanak tanır.
İstisna Hiyerarşisi: Birden fazla catch bloğu kullanırken, en spesifik istisnaları önce, en genel istisnayı (Exception) ise en sona yerleştirin. Aksi takdirde, genel istisna bloğu tüm istisnaları yakalayabilir ve daha spesifik bloklara asla ulaşılamaz.
finally Bloğunu Kullanın: Kaynakları serbest bırakmak (örn. dosya tanıtıcıları, veritabanı bağlantıları) veya temizlik işlemleri yapmak için finally bloğunu kullanın. Bu, kodun hem başarıyla tamamlandığı hem de bir istisna fırlatıldığı durumlarda tutarlılık sağlar.
Kendi İstisna Sınıflarınızı Oluşturun: PHP'nin öntanımlı istisnaları çoğu durumu kapsasa da, uygulamanıza özgü hata durumları için Exception sınıfından türeyen kendi istisna sınıflarınızı oluşturmanız, kodunuzu daha anlamlı ve yönetilebilir hale getirebilir.
Hata Mesajlarını Açık Tutun: İstisnaları fırlatırken, sorunun ne olduğunu ve nasıl düzeltilebileceğini açıklayan net ve bilgilendirici hata mesajları sağlayın. Bu, hata ayıklama sürecini büyük ölçüde hızlandırır.
İstisnaları Yutmaktan Kaçının: Bir istisnayı yakalayıp hiçbir şey yapmamak (boş bir catch bloğu) yaygın bir hatadır. Bu, hataların göz ardı edilmesine ve uygulamanızda gizli sorunlara yol açabilir. Her zaman yakaladığınız bir istisnayı işleyin (örn. loglayın, kullanıcıya bildirin veya yeniden fırlatın).
PHP geliştiricileri için öntanımlı değişkenler, web uygulamalarının kalbinde yer alan temel bir yapıdır. Bu değişkenler, PHP tarafından otomatik olarak oluşturulur ve bir betiğin herhangi bir yerinden erişilebilir durumdadırlar. HTTP isteklerinden oturum verilerine, sunucu bilgilerinden dosya yüklemelerine kadar uygulamanın farklı katmanlarından bilgiye erişimi kolaylaştırarak dinamik ve etkileşimli web sayfaları oluşturulmasına olanak tanırlar.
PHP, betik yürütülmeden önce veya yürütme sırasında otomatik olarak doldurulan bir dizi özel değişkene sahiptir. Bu değişkenler, "süper global" olarak da adlandırılır, çünkü kapsamları ne olursa olsun (fonksiyonlar, sınıflar veya global kapsam) PHP betiğinin her yerinden erişilebilirler. En yaygın kullanılan öntanımlı değişkenler şunlardır:
$_GET: HTTP GET metodu ile gönderilen verileri içerir.
$_POST: HTTP POST metodu ile gönderilen verileri içerir.
$_REQUEST: Hem $_GET hem de $_POST ve $_COOKIE verilerini içerir.
$_SESSION: Oturum değişkenlerini içerir. Oturum başlatıldıktan sonra kullanılabilir.
$_COOKIE: HTTP çerezlerini içerir.
$_SERVER: Sunucu ve yürütme ortamı hakkında bilgi içerir.
$_FILES: HTTP POST metodu ile yüklenen dosyalar hakkında bilgi içerir.
$_ENV: Ortam değişkenlerini içerir.
Öntanımlı değişkenler, bir dizi gibi davranır ve içerdikleri verilere anahtar-değer çiftleri aracılığıyla erişilir. Genel sözdizimi aşağıdaki gibidir:
$_DEĞİŞKEN_ADI['anahtar'];Burada;
$_DEĞİŞKEN_ADI: Erişmek istediğiniz öntanımlı değişkenin adını (örn. $_GET, $_POST) temsil eder.
'anahtar': Erişilmek istenen verinin benzersiz tanımlayıcısını temsil eder. Bu, bir HTML formundaki bir alanın name özelliği, bir URL sorgu parametresinin adı, bir çerezin adı veya bir sunucu bilgisinin spesifik bir etiketi olabilir.
Her bir süper global değişkenin işlevselliği ve tipik kullanım alanları aşağıda açıklanmıştır:
$_GET:
Tarayıcının adres çubuğunda (URL'de) ? işaretinden sonra gelen sorgu dizgisindeki parametrelere erişmek için kullanılır. Örneğin, example.com/sayfa.php?id=123&ad=test URL'sinde id ve ad parametrelerine $_GET['id'] ve $_GET['ad'] ile erişilebilir.
$_POST:
HTML formları aracılığıyla HTTP POST metodu kullanılarak gönderilen verilere erişmek için kullanılır. Bu veriler URL'de görünmez ve genellikle hassas bilgiler (şifreler) veya büyük veri setleri için tercih edilir.
$_REQUEST:
PHP'nin yapılandırmasına (variables_order) bağlı olarak $_GET, $_POST ve $_COOKIE değişkenlerinin içeriğini birleştirir. Ancak, değişken önceliği nedeniyle beklenmedik davranışlara yol açabileceği için genellikle doğrudan $_GET veya $_POST kullanılması önerilir.
$_SESSION:
Kullanıcı oturumları arasında veri saklamak için kullanılır. Bir kullanıcının web sitesindeki etkileşimlerini takip etmek (giriş durumu, sepet içeriği vb.) için idealdir. Kullanmadan önce session_start() fonksiyonu çağrılmalıdır.
$_COOKIE:
Kullanıcının tarayıcısında depolanan HTTP çerezlerine erişmek için kullanılır. Çerezler, kullanıcı tercihlerini veya kimlik bilgilerini saklamak gibi amaçlarla kullanılabilir.
$_SERVER:
Web sunucusu ve geçerli yürütme ortamı hakkında kapsamlı bilgi sağlar. Örneğin, $_SERVER['REQUEST_METHOD'] ile HTTP isteğinin metodunu (GET, POST), $_SERVER['REMOTE_ADDR'] ile kullanıcının IP adresini alabilirsiniz.
$_FILES:
HTML formları aracılığıyla yüklenen dosyalar hakkında bilgi (dosya adı, türü, boyutu, geçici konumu) içerir. Dosya yükleme işlemleri için özel olarak tasarlanmıştır.
$_ENV:
Çevre değişkenlerini içerir. Bu değişkenler, web sunucusunun (Apache, Nginx vb.) veya işletim sisteminin PHP betiğine sağladığı sistem düzeyindeki ayarlardır.
Aşağıdaki örnekler, öntanımlı değişkenlerin PHP betiklerinde nasıl kullanıldığını göstermektedir.
$_GET KullanımıBu örnekte, bir URL'den ad parametresini alıp ekrana yazdıracağız. Öncelikle, kullanıcıdan adını isteyen bir HTML formu oluşturalım:
GET Örneği
Adınızı Girin (GET)
Şimdi de islem.php dosyasında bu veriyi işleyelim:
Merhaba, " . $ad . "!";
} else {
echo "Lütfen adınızı girin.
";
}
?>$_POST KullanımıBu örnek, bir form aracılığıyla HTTP POST metodu ile gönderilen kullanıcı adını ve şifresini nasıl işleyeceğimizi gösterir. Yine bir HTML formu ile başlayalım:
POST Örneği
Giriş Yap (POST)
Şimdi de giris.php dosyasında bu veriyi işleyelim:
Hoş geldiniz, " . $kullanici_adi . "!";
} else {
echo "Kullanıcı adı veya şifre yanlış.
";
}
} else {
echo "Lütfen kullanıcı adı ve şifrenizi girin.
";
}
?>$_SESSION KullanımıBu örnek, oturum değişkenlerini kullanarak kullanıcı girişini simüle eder ve kullanıcının adını oturumda saklar.
Oturum başlatıldı ve 'kullanici_adi' Mehmet olarak ayarlandı.";
echo "";
?>
Oturumdaki kullanıcı adı: " . htmlspecialchars($_SESSION['kullanici_adi']) . "";
} else {
echo "Oturumda 'kullanici_adi' bulunamadı.
";
}
echo "";
?>
Oturum sonlandırıldı.";
echo "";
?>$_SERVER KullanımıBu örnek, $_SERVER değişkeni aracılığıyla sunucu ve istek bilgilerine nasıl erişileceğini gösterir.
Sunucu Bilgileri";
echo "İstek Metodu: " . $_SERVER['REQUEST_METHOD'] . "
";
echo "Sunucu Adı: " . $_SERVER['SERVER_NAME'] . "
";
echo "Sunucu Yazılımı: " . $_SERVER['SERVER_SOFTWARE'] . "
";
echo "İstek URI: " . $_SERVER['REQUEST_URI'] . "
";
echo "Kullanıcının IP Adresi: " . $_SERVER['REMOTE_ADDR'] . "
";
// Tüm _SERVER değişkenlerini görmek için:
// echo "";
// print_r($_SERVER);
// echo "
";
?>Veri Doğrulama ve Filtreleme: Kullanıcıdan gelen tüm girişler ($_GET, $_POST, $_COOKIE vb.), herhangi bir işlem yapılmadan veya veritabanına kaydedilmeden önce mutlaka doğrulanmalı ve filtrelenmelidir. Bu, SQL enjeksiyonu, XSS (Cross-Site Scripting) ve diğer güvenlik açıklarına karşı kritik bir önlemdir. PHP'nin htmlspecialchars(), strip_tags(), filter_var() gibi fonksiyonları bu amaçla kullanılabilir.
$_REQUEST Kullanımından Kaçınma: Değişken önceliği ayarları nedeniyle $_REQUEST kullanımı, beklenmedik sonuçlara yol açabilir. Mümkün olduğunca spesifik olarak $_GET veya $_POST kullanılması daha güvenli ve öngörülebilirdir.
isset() ile Kontrol: Öntanımlı değişkenlerdeki bir anahtara erişmeden önce, o anahtarın gerçekten var olup olmadığını isset() fonksiyonu ile kontrol etmek iyi bir uygulamadır. Bu, "Undefined index" uyarılarını ve potansiyel hataları önler.
Oturum Güvenliği: Oturum güvenliği için session_start() her sayfanın başında çağrılmalı ve oturum kimliği sabitleme (session fixation) ve oturum kaçırma (session hijacking) gibi risklere karşı dikkatli olunmalıdır. Oturum verileri hassas bilgiler içeriyorsa, ek şifreleme veya token mekanizmaları düşünülebilir.
Dosya Yükleme Güvenliği: $_FILES ile dosya yüklerken, yüklenen dosya türü, boyutu ve içeriği mutlaka doğrulanmalıdır. Kötü amaçlı dosyaların sunucuya yüklenmesini önlemek için sıkı kontroller uygulanmalıdır.
Ortam Değişkenleri ve Hassas Bilgiler: $_ENV ve $_SERVER gibi değişkenler hassas sunucu veya sistem yapılandırma bilgilerini içerebilir. Bu bilgilerin yanlışlıkla son kullanıcıya gösterilmemesine dikkat edilmelidir.
PHP 8.0 ile birlikte dile eklenen öznitelikler (attributes), kodunuza yapısal meta veriler eklemenin modern ve deklaratif bir yolunu sunar. Bu özellik, daha önce genellikle DocBlock yorumları aracılığıyla sağlanan bilgilerin, doğrudan dilin kendisi tarafından tanınabilen ve yansıma (reflection) API'si aracılığıyla erişilebilen bir formatta tanımlanmasına olanak tanır. Öznitelikler, sınıflara, yöntemlere, özelliklere, fonksiyonlara ve hatta parametrelere atanabilir, bu da framework'ler, ORM'ler, validasyon sistemleri ve diğer kod analiz araçları için güçlü ve tip güvenli bir mekanizma sağlar.
PHP'de bir öznitelik, köşeli parantezler (#[ ve ]) içine alınmış bir isim ve isteğe bağlı olarak parametreler ile tanımlanır. Bu isim, aslında bir PHP sınıfının adıdır ve bu sınıfın bir örneği, özniteliğin uygulandığı elemanla ilişkilendirilir.
Bir özniteliğin kendisi, #[Attribute] özniteliği ile işaretlenmiş basit bir PHP sınıfıdır. Bu işaretleme, PHP motoruna ilgili sınıfın bir öznitelik olarak kullanılabileceğini bildirir.
Öznitelik Sınıfı Tanımlama: Bir öznitelik oluşturmak için, #[Attribute] özniteliğini kullanarak bir sınıf tanımlamanız gerekir. Bu sınıf, özniteliğin davranışını veya içerdiği verileri belirler.
message = $message;
}
}
Hedef Kısıtlamaları: #[Attribute] özniteliğine parametreler geçirilerek, özniteliğin hangi türdeki elemanlara (sınıf, yöntem, özellik vb.) uygulanabileceği kısıtlanabilir. Bu, Attribute::TARGET_CLASS, Attribute::TARGET_METHOD, Attribute::TARGET_PROPERTY, Attribute::TARGET_FUNCTION, Attribute::TARGET_PARAMETER ve Attribute::TARGET_ALL gibi sabitlerle yapılır.
Tekrarlanabilir Öznitelikler: Varsayılan olarak, bir elemana aynı öznitelikten yalnızca bir tane uygulanabilir. Ancak, Attribute::IS_REPEATABLE sabiti kullanılarak bir özniteliğin birden çok kez uygulanmasına izin verilebilir.
name = $name;
}
}
Parametreler: Öznitelik sınıfları, constructor'ları aracılığıyla parametre alabilirler. Bu parametreler, özniteliği uygularken doğrudan parantez içinde belirtilir ve özniteliğin davranışını özelleştirmek için kullanılır.
Aşağıdaki örnekler, PHP özniteliklerinin nasıl tanımlandığını ve yansıma API'si (Reflection API) kullanılarak nasıl okunduğunu göstermektedir.
Örnek 1: Basit Bir Yönlendirme (Routing) Özniteliği
Bu örnek, bir web uygulamasında yöntemleri belirli URL yollarına bağlamak için kullanılabilecek basit bir #[Route] özniteliği tanımlar ve ardından bu özniteliği yansıma ile okur.
path = $path;
$this->methods = $methods;
}
}
class ApiController
{
#[Route("/api/users", "GET")]
public function getUsers(): array
{
return ['John Doe', 'Jane Smith'];
}
#[Route("/api/users/{id}", "GET")]
public function getUser(int $id): string
{
return "User ID: {$id}";
}
}
// Öznitelikleri yansıma ile okuma
$reflector = new ReflectionClass(ApiController::class);
foreach ($reflector->getMethods() as $method) {
echo "Metot: " . $method->getName() . "
";
foreach ($method->getAttributes(Route::class) as $attribute) {
$route = $attribute->newInstance(); // Öznitelik sınıfının bir örneğini oluşturur
echo " Yol: " . $route->path . ", Metotlar: " . implode(", ", $route->methods) . "
";
}
}
/* Çıktı:
Metot: getUsers
Yol: /api/users, Metotlar: GET
Metot: getUser
Yol: /api/users/{id}, Metotlar: GET
*/
Örnek 2: Validasyon (Doğrulama) Özniteliği ve Hedef Kısıtlaması
Bu örnek, bir özelliğin minimum ve maksimum değerler arasında olmasını gerektiren bir #[Range] özniteliği tanımlar ve bu özniteliği yalnızca özelliklere uygulanacak şekilde kısıtlar.
min = $min;
$this->max = $max;
}
}
class Product
{
#[Range(min: 0, max: 100)]
public int $stock;
#[Range(min: 1, max: 999)]
public float $price;
public function __construct(int $stock, float $price)
{
$this->stock = $stock;
$this->price = $price;
}
}
// Öznitelikleri yansıma ile okuma
$reflector = new ReflectionClass(Product::class);
foreach ($reflector->getProperties() as $property) {
echo "Özellik: " . $property->getName() . "
";
foreach ($property->getAttributes(Range::class) as $attribute) {
$range = $attribute->newInstance();
echo " Min: " . $range->min . ", Max: " . $range->max . "
";
}
}
/* Çıktı:
Özellik: stock
Min: 0, Max: 100
Özellik: price
Min: 1, Max: 999
*/
Örnek 3: Tekrarlanabilir Öznitelikler
Bu örnek, bir sınıfın birden fazla etiketle işaretlenmesine olanak tanıyan tekrarlanabilir bir #[Tag] özniteliği tanımlar.
name = $name;
}
}
#[Tag("Veritabanı")]
#[Tag("ORM")]
#[Tag("PHP 8")]
class UserRepository
{
// ...
}
// Öznitelikleri yansıma ile okuma
$reflector = new ReflectionClass(UserRepository::class);
echo "Sınıf: " . $reflector->getName() . "
";
foreach ($reflector->getAttributes(Tag::class) as $attribute) {
$tag = $attribute->newInstance();
echo " Etiket: " . $tag->name . "
";
}
/* Çıktı:
Sınıf: UserRepository
Etiket: Veritabanı
Etiket: ORM
Etiket: PHP 8
*/
Performans Avantajı: Öznitelikler, DocBlock yorumlarının aksine, PHP'nin derleme aşamasında işlenir. Bu, çalışma zamanında ek bir ayrıştırma (parsing) yükü oluşturmadıkları anlamına gelir ve performans açısından DocBlock tabanlı çözümlerden daha verimlidir.
Kullanım Alanları: Öznitelikler, framework'lerde (örneğin, yönlendirme, ORM eşlemesi), validasyon kuralı tanımlarında, seri hale getirme (serialization) işlemlerinde, kod üretimi (code generation) araçlarında ve IDE entegrasyonlarında yaygın olarak kullanılır.
Yansıma API'si (Reflection API): Özniteliklere erişim yalnızca PHP'nin Yansıma API'si aracılığıyla mümkündür. ReflectionClass::getAttributes(), ReflectionMethod::getAttributes() gibi yöntemler, uygulanan öznitelikleri almanızı sağlar.
Ad Alanları (Namespaces): Öznitelik sınıflarını kullanırken, tıpkı diğer sınıflarda olduğu gibi ad alanlarını (namespaces) doğru bir şekilde belirtmeli veya use ifadesiyle içe aktarmalısınız.
PHP Sürümü: Öznitelikler özelliği sadece PHP 8.0 ve sonraki sürümlerde mevcuttur. Daha önceki PHP sürümlerinde kullanılmaya çalışıldığında ayrıştırma hatasına neden olur.
Constructor Bağımsız Değişkenleri: Öznitelik sınıflarının constructor'ları, tip ipuçları (type hints) ile tanımlanan bağımsız değişkenleri kabul edebilir. Bu, özniteliğe geçirilen değerlerin tip güvenliğini sağlar.
Sözdizimi Esnekliği: Öznitelikler, tek bir satırda veya birden fazla satıra yayılarak tanımlanabilir, bu da kod okunabilirliğini artırır.
function generatorFunction(): Generator
{
yield $value;
// veya
yield $key => $value;
}
function generatorFunction(): Generator: Bu kısım, bir üreteç fonksiyonunun tanımlandığını belirtir. Fonksiyon adı herhangi bir geçerli PHP fonksiyon adı olabilir. PHP 7.0 ve sonrası için dönüş tipi ipucu olarak Generator kullanılabilir, bu fonksiyonun bir üreteç döndüreceğini açıkça belirtir.
yield $value;: Üreteçlerin kalbinde yer alan anahtar kelimedir. Bir fonksiyon içerisinde yield ifadesi kullanıldığında, PHP bu fonksiyonu otomatik olarak bir üreteç fonksiyonu olarak tanır. yield, fonksiyonun yürütülmesini duraklatır, belirtilen $value değerini çağırana geri döndürür ve fonksiyonun mevcut durumunu (yerel değişkenler, yürütme noktası vb.) korur. Bir sonraki değer istendiğinde, fonksiyon kaldığı yerden yürütülmeye devam eder.
yield $key => $value;: yield ifadesi, anahtar-değer çiftleri döndürmek için de kullanılabilir, tıpkı bir dizideki gibi. Bu, özellikle değerlerin belirli bir anahtarla ilişkilendirilmesi gereken durumlarda faydalıdır.
Bir üreteç fonksiyonu çağrıldığında, kodu hemen yürütülmez. Bunun yerine, bir Generator nesnesi döndürür. Fonksiyonun kodu ancak bu nesne üzerinde döngüye başlandığında (örneğin bir foreach döngüsü ile) adım adım yürütülür ve yield ifadeleri aracılığıyla değerler üretilir.
$i, 'ad' => 'Kullanıcı ' . $i, 'email' => 'kullanici' . $i . '@example.com'];
}
echo "Veritabanı bağlantısı kapatılıyor..." . PHP_EOL;
}
// Sadece 3 kayıt işleyelim
foreach (veritabaniKayitlari(3) as $kayit) {
echo "İşlenen kayıt ID: " . $kayit['id'] . ", Ad: " . $kayit['ad'] . PHP_EOL;
}
// Çıktı:
// Veritabanı bağlantısı açılıyor...
// Kayıt 1 çekiliyor...
// İşlenen kayıt ID: 1, Ad: Kullanıcı 1
// Kayıt 2 çekiliyor...
// İşlenen kayıt ID: 2, Ad: Kullanıcı 2
// Kayıt 3 çekiliyor...
// İşlenen kayıt ID: 3, Ad: Kullanıcı 3
// Veritabanı bağlantısı kapatılıyor...
?>Bellek Verimliliği: Üreteçlerin en büyük avantajı bellek verimliliğidir. Tüm veri setini belleğe yüklemek yerine, değerleri talep üzerine ürettikleri için büyük dosyaları veya veritabanı sonuçlarını işlerken çok daha az bellek kullanırlar.
Tek Kullanımlık Yapı: PHP'deki üreteçler, ileriye dönük (forward-only) yineleyicilerdir. Bir üreteç üzerinde döngü tamamlandığında, genellikle en başa dönüp tekrar yinelemek mümkün değildir. Eğer tekrar kullanım gerekiyorsa, üreteç fonksiyonunu tekrar çağırmanız gerekir.
yield from Kullanımı: PHP 7.0 ile birlikte gelen yield from ifadesi, bir üreteçten başka bir üretece veya Traversable nesneye yetki devretmeyi sağlar. Bu, birden fazla iç içe üreteci tek bir yerden yönetmek için kullanışlıdır.
İstisna Yönetimi: Üreteç fonksiyonları içinde istisnalar fırlatılabilir ve bunlar normal fonksiyonlarda olduğu gibi yakalanabilir. Üreteç, bir istisna fırlattığında veya sonlandığında, artık daha fazla değer üretmez.
Dönüş Değeri: PHP 7.0 ve sonrası ile üreteçler, return ifadesi ile bir nihai değer döndürebilir. Ancak bu değere doğrudan foreach döngüsü üzerinden erişilemez. Generator::getReturn() metodu ile erişilebilir ve genellikle yield from ile birlikte kullanılır.
PHP programlamada, bir uygulamanın çalışma zamanında beklenmedik durumlarla karşılaşması yaygın bir senaryodur. Bu tür durumlar, programın normal akışını bozarak hatalara veya istenmeyen davranışlara yol açabilir. PHP'de bu tür durumları zarif ve kontrollü bir şekilde yönetmek için istisnalar (exceptions) mekanizması kullanılır. İstisnalar, hata koşullarını temsil eden nesnelerdir ve programın hatayı yakalamasına, işlemesine ve uygun bir yanıt vermesine olanak tanır. Bu kılavuz, PHP dilinde istisnaların temel sözdizimini, detaylı kullanımını ve pratik örneklerini adım adım açıklamaktadır.
PHP'de istisna yönetimi, try, catch ve isteğe bağlı olarak finally blokları kullanılarak gerçekleştirilir. Bu yapı, potansiyel olarak istisna fırlatabilecek kodun yürütülmesini izlemek ve fırlatılan istisnaları ele almak için tasarlanmıştır.
İstisna yönetimi yapısının her bir bileşeni belirli bir amaca hizmet eder:
try Bloğu: Potansiyel olarak bir istisna fırlatabilecek kodun bulunduğu alandır. Program bu blok içindeki kodun yürütülmesini izler. Eğer try bloğu içinde bir istisna fırlatılırsa, PHP normal akışı durdurur ve fırlatılan istisnayı yakalayabilecek uygun bir catch bloğu arar.
catch Bloğu: Bir try bloğunda fırlatılan istisnaları yakalamak ve işlemek için kullanılır. Her catch bloğu, yakalamak istediği istisna tipini (sınıfını) belirtir. PHP, fırlatılan istisna nesnesinin tipiyle eşleşen ilk catch bloğunu yürütür. Bir istisna yakalandığında, catch bloğu içindeki kod çalıştırılır ve bu, hatanın ele alınmasını sağlar. Birden fazla catch bloğu kullanarak farklı istisna tiplerini ayrı ayrı ele alabilirsiniz.
finally Bloğu: PHP 5.5'ten itibaren kullanılabilen bu blok, try ve catch blokları tamamlandıktan sonra, bir istisna fırlatılsın veya fırlatılmasın, her zaman yürütülecek kodu içerir. Bu, veritabanı bağlantılarını kapatma, dosya tanıtıcılarını serbest bırakma gibi temizleme (cleanup) işlemleri için son derece kullanışlıdır ve kaynak sızıntılarını önlemeye yardımcı olur.
throw Anahtar Kelimesi: Bir istisna fırlatmak için kullanılır. Bir Exception sınıfının veya ondan türetilmiş bir sınıfın nesnesiyle birlikte kullanılır. Örneğin: throw new Exception("Hata mesajı");
Exception Sınıfı: PHP'de tüm yerleşik ve özel istisnaların türediği temel sınıftır. Kendi özel istisna sınıflarınızı oluştururken genellikle bu sınıftan türetirsiniz.
Aşağıdaki örnekler, istisna yönetiminin farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
Örnek 1: Temel İstisna Yakalama
";
echo bolmeIslemi(5, 0) . "
"; // Bu satırda istisna fırlatılacak
echo bolmeIslemi(20, 4) . "
"; // Bu satır çalışmayacak
} catch (Exception $e) {
echo "Hata yakalandı: " . $e->getMessage() . "
";
}
echo "Program devam ediyor.
";
?>Bu örnekte, bolmeIslemi fonksiyonu sıfıra bölme durumunda bir istisna fırlatır. try bloğu içinde bu istisna yakalanır ve hata mesajı ekrana yazdırılır. İstisna fırlatıldıktan sonra try bloğundaki diğer kodların çalışmadığına dikkat edin.
Örnek 2: Çoklu catch Blokları ve Özel İstisnalar
Kendi özel istisna sınıflarınızı tanımlayarak daha spesifik hata durumlarını ele alabilirsiniz. Özel istisna sınıfları genellikle Exception sınıfından türetilir.
getMessage() . "
";
} catch (VeritabaniBaglantiHatasiException $e) {
echo "Veritabanı hatası yakalandı: " . $e->getMessage() . "
";
} catch (Exception $e) { // Diğer tüm istisnaları yakalamak için
echo "Genel bir hata yakalandı: " . $e->getMessage() . "
";
} finally {
echo "İşlem tamamlandı, kaynaklar serbest bırakılıyor (finally bloğu).
";
}
?>Bu örnek, farklı hata türlerini ele almak için birden çok catch bloğunun nasıl kullanılacağını gösterir. finally bloğu ise, istisna fırlatılsa da fırlatılmasa da her zaman çalışarak temizleme işlemleri için bir garanti sağlar.
Örnek 3: İstisnaları Yeniden Fırlatma (Re-throwing Exceptions)
Bazen bir istisnayı yakalayıp belirli bir işlem yaptıktan sonra, daha yüksek bir seviyede ele alınması için yeniden fırlatmak isteyebilirsiniz.
getMessage());
// İstisnayı daha yüksek bir seviyede yakalanmak üzere yeniden fırlat
throw new Exception("Dosya işlemi sırasında bir sorun oluştu.", 0, $e);
}
}
try {
$data = dosyaOku("olmayan_dosya.txt");
echo "Dosya içeriği: " . $data . "
";
} catch (Exception $e) {
echo "Uygulama seviyesinde hata: " . $e->getMessage() . "
";
if ($e->getPrevious()) {
echo "Önceki hata: " . $e->getPrevious()->getMessage() . "
";
}
}
?>Bu örnekte, dosyaOku fonksiyonu bir istisna yakalar, loglar ve ardından daha genel bir istisna mesajıyla yeniden fırlatır. Yeniden fırlatılan istisnaya orijinal istisna, getPrevious() metodu ile erişilebilir.
Spesifik catch Blokları Önce Gelmeli: Birden fazla catch bloğu kullanırken, daha spesifik istisna sınıflarını (GecersizParametreException gibi) genel Exception sınıfından önce yerleştirin. Aksi takdirde, daha genel olan blok tüm istisnaları yakalar ve spesifik bloklara asla ulaşılamaz.
İstisnaları Yutmaktan Kaçının: Bir istisnayı yakalayıp hiçbir işlem yapmadan (boş bir catch bloğu) bırakmak, hataların gizlenmesine ve hata ayıklamanın zorlaşmasına neden olur. Her zaman yakalanan istisnayı loglayın, kullanıcıya anlamlı bir mesaj gösterin veya uygun şekilde ele alın.
Sadece Hata Durumları İçin Kullanın: İstisnalar, programın normal akışının bir parçası olmayan, beklenmedik hata durumları için tasarlanmıştır. Kontrol akışını yönlendirmek için istisnaları kullanmaktan kaçının (örneğin, bir döngüyü kırmak için).
Throwable Arayüzü: PHP 7'den itibaren, hem Exception hem de Error sınıflarının uyguladığı Throwable arayüzü tanıtılmıştır. Bu, hem istisnaları hem de ciddi hataları (örneğin, bellek tükenmesi) tek bir catch (Throwable $e) bloğu ile yakalamanıza olanak tanır.
Standart İstisna Sınıfları: PHP, InvalidArgumentException, RuntimeException, PDOException gibi birçok yerleşik istisna sınıfı sağlar. Uygulamanızda bu standart sınıfları veya bunlardan türettiğiniz özel sınıfları kullanmak iyi bir pratiktir.
PHP dilinde hata ve istisna yönetimi, uygulamaların beklenmedik durumlarla nasıl başa çıktığını belirleyen kritik bir konudur. Etkili hata yönetimi, uygulamanın kararlılığını artırır, kullanıcı deneyimini iyileştirir ve hata ayıklama süreçlerini önemli ölçüde kolaylaştırır. PHP, hem geleneksel hata işleme yaklaşımları hem de modern istisna mekanizmaları sunarak geliştiricilere esneklik sağlar.
PHP'de hata ve istisna yönetimi, genellikle iki ana mekanizma etrafında şekillenir:
İstisna Yönetimi: Potansiyel olarak hata oluşturabilecek kod bloklarını sarmalamak ve bu bloklarda fırlatılan istisnaları yakalamak için try...catch...finally yapıları kullanılır. Özel durumları belirtmek için throw ifadesiyle istisnalar fırlatılabilir.
Geleneksel Hata İşleme: PHP'nin eski sürümünden gelen ve E_NOTICE, E_WARNING gibi hata seviyelerini içeren hatalar için set_error_handler() fonksiyonu ile özel hata işleyicileri tanımlanabilir.
PHP'nin hata ve istisna yönetimi yapıları aşağıdaki bileşenlerden oluşur:
try Bloğu: İstisna fırlatma potansiyeli olan kodun yerleştirildiği bloktur. Bu blok içindeki herhangi bir istisna fırlatıldığında, normal akış durur ve uygun catch bloğu aranır.
catch Bloğu: Bir try bloğu içinde fırlatılan belirli bir türdeki istisnayı yakalamak için kullanılır. catch bloğu, yakalanan istisnayı parametre olarak alır ve bu istisna üzerinde işlem yapılmasına olanak tanır. PHP 7'den itibaren birden fazla catch bloğu tanımlanabilir ve bir catch bloğu birden fazla istisna türünü | operatörü ile yakalayabilir.
finally Bloğu (PHP 5.5+): İster bir istisna fırlatılsın ister fırlatılmasın, try ve catch bloklarından sonra her durumda çalıştırılması garanti edilen kod bloğudur. Bu genellikle kaynakların serbest bırakılması veya temizlik işlemleri için kullanılır.
throw İfadesi: Manuel olarak bir istisna nesnesi fırlatmak için kullanılır. Genellikle bir koşul sağlanmadığında veya beklenmedik bir durum oluştuğunda programın akışını kontrol altına almak için tercih edilir.
set_error_handler(callable $handler, int $error_types = E_ALL | E_STRICT): PHP'nin varsayılan hata işleyicisini özel bir fonksiyonla değiştirmeye yarar. Bu fonksiyon, E_ERROR dışındaki tüm hata türlerini (E_WARNING, E_NOTICE vb.) yakalayabilir. Fonksiyon, hata kodu, hata mesajı, dosya adı ve satır numarası gibi parametreler alır.
restore_error_handler(): Daha önce set_error_handler() ile değiştirilmiş olan hata işleyiciyi PHP'nin varsayılan işleyicisine geri döndürür.
error_reporting(int $level): Hangi hata seviyelerinin raporlanacağını belirler. Geliştirme ortamında genellikle tüm hatalar raporlanırken (E_ALL), üretim ortamında daha düşük seviyeli hatalar gizlenir.
display_errors ve log_errors: PHP'nin php.ini dosyasında veya çalışma zamanında ayarlanabilen bu yönergeler, hataların tarayıcı çıktısında gösterilip gösterilmeyeceğini ve hata günlüklerine yazılıp yazılmayacağını kontrol eder.
Aşağıdaki örnekler, PHP'de hata ve istisna yönetiminin farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
1. Temel try...catch Kullanımı
"; // Çalışır
echo bolmeIslemi(10, 0) . "
"; // İstisna fırlatır
echo "Bu satır çalışmayacak.
";
} catch (Exception $e) {
echo "Hata yakalandı: " . $e->getMessage() . "
";
}
?>2. Özel İstisna Sınıfı Tanımlama ve Kullanımı
getMessage() . " (Kod: " . $this->getCode() . ")";
}
}
function veritabaninaBaglan() {
// Bağlantı denemesi yapıldığı varsayılsın
$basarili = false; // Bağlantının başarısız olduğunu simüle edelim
if (!$basarili) {
throw new VeritabaniBaglantiHatasi("Veritabanı sunucusuna ulaşılamıyor.");
}
return "Bağlantı başarılı!";
}
try {
echo veritabaninaBaglan() . "
";
} catch (VeritabaniBaglantiHatasi $e) {
echo $e->hataMesaji() . "
";
} catch (Exception $e) { // Genel istisnaları yakalamak için
echo "Genel bir hata oluştu: " . $e->getMessage() . "
";
}
?>3. finally Bloğu Kullanımı
";
// Dosya okuma işlemleri...
} catch (Exception $e) {
echo "Hata: " . $e->getMessage() . "
";
} finally {
if ($dosyaKaynagi) {
fclose($dosyaKaynagi);
echo "Dosya kapatıldı.
";
} else {
echo "Dosya zaten açık değildi veya açma başarısız oldu.
";
}
}
}
dosyaIslemi("olmayan_dosya.txt");
dosyaIslemi("varolan_dosya.txt"); // Bu dosyayı manuel olarak oluşturmanız gerekebilir
?>4. set_error_handler() ile Geleneksel Hata Yakalama
Özel Hata: [$errno] $errstr - $errfile:$errline
";
// Hata günlüğüne yazma
error_log("Özel Hata [$errno]: $errstr - $errfile:$errline");
// TRUE döndürmek, PHP'nin dahili hata işleyicisinin çalışmasını engeller.
return true;
}
// Özel hata işleyiciyi ayarla
set_error_handler("ozelHataIsleyici");
// E_WARNING seviyesinde bir hata oluştur
echo $tanimsizDegisken; // E_NOTICE veya E_WARNING oluşturabilir
// E_NOTICE seviyesinde bir hata oluştur
$dizi = [];
echo $dizi[0];
// Özel hata işleyiciyi eski haline getir
restore_error_handler();
// Bu hata artık varsayılan işleyici tarafından ele alınır (veya gizlenir)
trigger_error("Bu hata artık eski işleyiciye döner.", E_USER_WARNING);
?>Throwable Arayüzü (PHP 7+): PHP 7'den itibaren hem Error (dahili PHP hataları) hem de Exception (kullanıcı tanımlı ve standart istisnalar) sınıfları Throwable arayüzünü uygular. Bu sayede catch (Throwable $e) kullanarak tüm yakalanabilir hataları ve istisnaları tek bir blokta ele alabilirsiniz.
Hata Seviyeleri: PHP, E_ERROR, E_WARNING, E_NOTICE, E_PARSE gibi birçok hata seviyesi tanımlar. Uygulamanızın davranışını ve hata raporlama düzeyini bu seviyeleri kullanarak kontrol etmek önemlidir.
Üretim Ortamında Hata Gösterimi: Üretim ortamında display_errors ayarının Off (kapalı) olduğundan emin olun. Hataların doğrudan kullanıcıya gösterilmesi güvenlik zafiyetlerine yol açabilir. Bunun yerine, log_errors ayarını On (açık) yaparak hataları güvenli bir günlük dosyasına yazdırın.
Hata Günlükleme: error_log() fonksiyonu, hataları PHP'nin yapılandırılmış günlük dosyasına veya belirtilen bir hedefe yazmak için kullanılabilir. Özel hata işleyicileriniz içinde bu fonksiyonu kullanarak detaylı hata kayıtları tutmanız önerilir.
İstisna Hiyerarşisi: Birden fazla catch bloğu kullanırken, istisnaları en spesifikten en genele doğru sıralayın. Örneğin, özel bir istisna sınıfını (VeritabaniBaglantiHatasi) genel bir Exception sınıfından önce yakalayın.
Boş catch Bloklarından Kaçının: Bir istisnayı yakalayıp hiçbir işlem yapmamak (boş catch bloğu), hatanın gözden kaçmasına ve uygulamanın beklenmedik şekillerde davranmasına neden olabilir. Her zaman yakalanan istisnaları günlüğe kaydedin veya uygun bir şekilde ele alın.
İnternet dünyasının temel taşlarından biri olan PHP, web sitelerinin dinamik ve interaktif olmasını sağlayan güçlü bir programlama dilidir. Milyonlarca web sitesinin ve popüler web uygulamalarının arkasındaki teknoloji olan PHP, özellikle sunucu tarafı (server-side) web geliştirmede kendine sağlam bir yer edinmiştir. Peki, tam olarak PHP nedir? Nasıl çalışır ve neden bu kadar popülerdir? Bu kapsamlı rehberde, PHP'nin ne olduğunu, tarihçesini, temel özelliklerini, kullanım alanlarını, avantajlarını ve geleceğini detaylı bir şekilde inceleyeceğiz. Web geliştirme dünyasına adım atmak isteyenler veya mevcut bilgilerini pekiştirmek isteyenler için bu makale, PHP'nin derinliklerine inen bir yolculuk sunacak.
PHP, açılımı "Hypertext Preprocessor" olan, geniş ölçüde kullanılan, açık kaynaklı bir sunucu taraflı komut dosyası dilidir. Aslen "Personal Home Page" olarak başlayan bu isim, zamanla dilin yetenekleri genişledikçe değiştirilmiştir. PHP, özellikle web geliştirmeye odaklanmıştır ve HTML içine gömülebilir. Yani, bir HTML belgesi içerisinde PHP kodları yazabilir ve bu kodların sunucu tarafından işlenerek dinamik içerik üretmesini sağlayabilirsiniz.
PHP'nin temel amacı, statik HTML sayfalarının aksine, her kullanıcı isteğinde veya belirli koşullara göre değişebilen dinamik web sayfaları oluşturmaktır. Örneğin, bir kullanıcının oturum açtığında farklı bir içerik görmesi, bir e-ticaret sitesinde ürün listelerinin veritabanından çekilmesi veya bir blog sitesinde yorumların anında yayınlanması gibi işlevler, PHP gibi sunucu taraflı diller sayesinde mümkün olur. Bu dinamizm, web sitelerini daha etkileşimli, kişiselleştirilmiş ve güncel hale getirir.
PHP, sunucu üzerinde çalışır ve bir web tarayıcısı tarafından istenen bir PHP dosyasını işler. Sunucu, PHP kodunu çalıştırır, sonuçları (genellikle HTML olarak) oluşturur ve bu çıktıyı tarayıcıya gönderir. Tarayıcıya ulaşan tek şey, nihai HTML çıktısıdır; orijinal PHP kodu asla istemci tarafına gönderilmez. Bu, hem güvenlik hem de performans açısından önemli bir avantajdır.
PHP'nin hikayesi, 1994 yılında Rasmus Lerdorf adında bir geliştiricinin kendi kişisel ana sayfasını yönetmek için bir dizi C dilinde CGI (Common Gateway Interface) ikilisi yazmasıyla başladı. Bu araçlar, form verilerini işlemek ve MySQL veritabanlarıyla etkileşim kurmak gibi basit görevleri yerine getiriyordu. Lerdorf, bu araçları "Personal Home Page/Forms Interpreter" (PHP/FI) olarak adlandırdı ve 1995 yılında kaynak kodunu halka açık hale getirdi.
PHP/FI'nin popülaritesi hızla arttı ve diğer geliştiriciler de kendi web sitelerinde kullanmaya başladı. Geri bildirimler ve katkılarla dil gelişmeye devam etti. 1997 yılında, Andi Gutmans ve Zeev Suraski adında iki geliştirici, PHP/FI'nin çekirdeğini yeniden yazmaya karar verdi. Bu yeniden yazım, performans ve modülerlik açısından önemli iyileştirmeler getirdi ve "Zend Engine" adını aldı. 1998'de, bu yeni sürüm PHP 3.0 olarak piyasaya sürüldü ve dilin adını "PHP: Hypertext Preprocessor" olarak değiştirdi.
PHP 4.0, 2000 yılında piyasaya sürüldü ve daha da geliştirilmiş bir Zend Engine (Zend Engine 1.0) ile birlikte geldi. Bu sürüm, oturum desteği, çıktı tamponlama ve daha iyi web sunucusu entegrasyonu gibi önemli özellikler ekledi. PHP 4, dilin küresel çapta benimsenmesinde kritik bir rol oynadı.
2004 yılında, PHP 5.0, tamamen yeniden tasarlanmış bir Zend Engine (Zend Engine 2.0) ile birlikte çıktı. Bu sürüm, özellikle nesne yönelimli programlama (OOP) desteğini önemli ölçüde geliştirdi, XML ve veritabanı entegrasyonunu iyileştirdi ve birçok yeni özellik ekledi. PHP 5, uzun yıllar boyunca web geliştirmenin temel direği oldu.
En büyük sıçramalardan biri, 2015 yılında piyasaya sürülen PHP 7 serisi oldu. PHP 6 projesi başarısızlıkla sonuçlandıktan sonra, geliştiriciler doğrudan PHP 7'ye geçtiler. PHP 7, Zend Engine 3.0'ı tanıttı ve performans açısından devrim niteliğinde iyileştirmeler getirdi. PHP 5'e kıyasla çoğu uygulamada iki kat daha hızlı çalışabiliyordu. Ayrıca, yeni tür bildirimleri, anonim sınıflar ve daha birçok modern programlama özelliği eklendi.
PHP'nin en son büyük sürümü olan PHP 8, 2020 yılında yayınlandı. JIT (Just In Time) derleyici, nitelikler (attributes), adlandırılmış argümanlar, birleşim türleri (union types) ve match ifadesi gibi heyecan verici yeni özellikler sunarak dilin gücünü ve modernliğini daha da artırdı. PHP, sürekli gelişen, güncel ve performans odaklı bir dil olmaya devam etmektedir.
PHP'nin web geliştirme dünyasındaki kalıcı popülaritesi, sunduğu bir dizi önemli avantajdan kaynaklanmaktadır:
PHP'nin kullanım alanları oldukça geniştir ve internetin önemli bir bölümünü oluşturur. İşte PHP'nin en yaygın kullanıldığı bazı alanlar:
PHP'nin çalışma prensibi, bir web sitesini ziyaret ettiğinizde gerçekleşen adımları anlamak için önemlidir. İşte basit bir açıklama:
Bu süreç, her web sayfası isteği için tekrarlanır ve PHP'nin dinamik ve etkileşimli web deneyimleri sunmasını sağlar.
PHP'nin gücü, sadece dilin kendisinden değil, aynı zamanda etrafında inşa edilen zengin ekosistemden de gelir. Bu ekosistem, geliştiricilerin daha hızlı, daha verimli ve daha güvenli uygulamalar oluşturmasına yardımcı olan birçok araç, kütüphane ve çerçeve içerir.
Bazı dönemlerde "PHP öldü mü?" gibi sorular ortaya çıksa da, PHP her geçen gün kendini yenileyen ve geliştiren canlı bir dildir. PHP 7 ve PHP 8 ile gelen performans iyileştirmeleri, modern özellikler ve sürekli devam eden geliştirme süreçleri, dilin web geliştirme dünyasındaki yerini sağlamlaştırmıştır. Büyük teknoloji şirketleri (Facebook, Wikipedia) hala PHP'ye yatırım yapmakta, Laravel gibi çerçeveler yenilikçi çözümler sunmakta ve WordPress gibi CMS'ler milyonlarca siteye güç vermeye devam etmektedir. PHP, bulut tabanlı mimariler, mikro hizmetler ve API odaklı geliştirme gibi modern yaklaşımlara da başarıyla adapte olmaktadır. Bu nedenle, PHP'nin geleceği parlak ve web geliştirmenin vazgeçilmez bir parçası olmaya devam edecektir.
Eğer PHP öğrenmeye başlamak istiyorsanız, işte size bazı adımlar ve kaynaklar:
Bu bölümde, PHP hakkında en çok merak edilen bazı sorulara yanıt bulacaksınız.
PHP öğrenmek zor mu?
Hayır, PHP genel olarak öğrenmesi kolay bir dildir, özellikle web geliştirme dünyasına yeni başlayanlar için. Sözdizimi diğer bazı dillerden daha basittir ve geniş bir topluluk desteği ile bol miktarda kaynak mevcuttur. Temel HTML ve CSS bilginiz varsa, PHP'ye adapte olmanız daha da kolay olacaktır.
PHP hala popüler mi?
Kesinlikle evet. Bazı iddialara rağmen, PHP web geliştirme dünyasının en popüler dillerinden biri olmaya devam ediyor. Milyonlarca web sitesi, özellikle WordPress gibi büyük platformlar PHP ile çalışıyor. PHP 7 ve PHP 8 ile gelen performans iyileştirmeleri ve modern özellikler, dilin canlılığını korumasını sağlıyor.
PHP ile neler yapılabilir?
PHP ile dinamik web siteleri, e-ticaret platformları, bloglar, forumlar, sosyal medya siteleri, API'ler, İçerik Yönetim Sistemleri (CMS) ve hatta bazı komut satırı uygulamaları geliştirebilirsiniz. İnternette gördüğünüz çoğu dinamik içeriğin arkasında PHP veya benzeri bir sunucu taraflı dil bulunur.
PHP hangi veritabanlarıyla çalışır?
PHP, MySQL, PostgreSQL, SQLite, Microsoft SQL Server, Oracle ve MongoDB gibi birçok farklı veritabanıyla sorunsuz bir şekilde entegre olabilir. En yaygın kullanılanı MySQL'dir, ancak PHP'nin esnekliği sayesinde çoğu modern veritabanıyla çalışabilir.
PHP hangi işletim sistemlerinde çalışır?
PHP, platformdan bağımsız bir dildir. Linux, Windows, macOS ve Unix tabanlı sistemler dahil olmak üzere hemen hemen tüm büyük işletim sistemlerinde çalışabilir. Bu, geliştiricilere ve sunucu yöneticilerine büyük bir esneklik sunar.
PHP mi yoksa Python mu daha iyi?
Her iki dilin de kendine özgü güçlü yönleri vardır. PHP, web geliştirmeye odaklanmış ve bu alanda çok güçlü bir ekosisteme sahiptir. Python ise daha genel amaçlı bir dil olup web geliştirmeyle birlikte veri bilimi, yapay zeka ve otomasyon gibi alanlarda da yaygın olarak kullanılır. Seçim, projenizin gereksinimlerine ve kişisel tercihlerinize bağlıdır.
PHP mi yoksa JavaScript (Node.js) mi daha iyi?
PHP ve Node.js (JavaScript'in sunucu tarafı çalışma zamanı) her ikisi de sunucu tarafı geliştirme için popüler seçeneklerdir. PHP genellikle geleneksel web uygulamaları ve CMS'ler için tercih edilirken, Node.js gerçek zamanlı uygulamalar, mikro hizmetler ve tek sayfa uygulamalarının (SPA) API katmanları için güçlüdür. İki dil de modern web geliştirmede önemli bir rol oynar ve çoğu zaman birlikte kullanılırlar (örneğin, PHP bir web sitesinin arka ucunu sağlarken, JavaScript ön yüzü dinamik hale getirir).
PHP'de isim alanları (namespaces), kod organizasyonunu ve çakışmaları önlemeyi sağlayan güçlü bir özelliktir. Büyük ölçekli uygulamalarda veya üçüncü taraf kütüphanelerle çalışırken, aynı isimde sınıfların, arayüzlerin, fonksiyonların veya sabitlerin tanımlanması olası bir sorundur. İsim alanları, bu tür isim çakışmalarını (name collision) engellemek ve kodun daha modüler, okunabilir ve yönetilebilir olmasını sağlamak için bir kapsülleme katmanı sunar.
Bir PHP dosyasında isim alanı tanımlamak için namespace anahtar kelimesi kullanılır.
İsim alanı sözdiziminin temel bileşenleri şunlardır:
namespace anahtar kelimesi: Bir dosya için isim alanı bildirimini başlatır. Bu bildirim, dosyadaki tüm sınıflar, arayüzler, özellikler (traits), fonksiyonlar ve sabitler için geçerlidir.
Vendor\Project\Module: Bu kısım, tanımlanan isim alanının adını temsil eder. Genellikle ters eğik çizgi (\) ile ayrılmış hiyerarşik bir yapı kullanılır. PHP topluluğu arasında kabul gören PSR-4 autoloading standardı, genellikle isim alanı adlarının vendor (sağlayıcı), project (proje) ve module/sub-module (modül/alt modül) yapısını takip etmesini önerir.
İsim alanı bildirimi, dosyanın en üstünde, declare anahtar kelimesinden sonra ve PHP kodundan önce yapılmalıdır. Tek bir dosyada birden fazla isim alanı bildirimine izin verilmez.
Global isim alanı: Herhangi bir namespace bildirimi olmayan tüm kodlar global isim alanı içinde kabul edilir. Bir isim alanı içinde global isim alanındaki bir sınıfa veya fonksiyona erişmek için \ öneki kullanılır (örneğin, \DateTime).
Aşağıdaki örnekler, isim alanlarının farklı senaryolarda nasıl kullanıldığını göstermektedir.
Örnek 1: Temel İsim Alanı Tanımı ve Kullanımı
İki farklı isim alanında aynı isimde sınıfların nasıl tanımlandığını ve kullanıldığını gösterir.
Çıktı:
Veritabanı bağlantısı oluşturuldu (App\Database).
API bağlantısı oluşturuldu (App\Api).Örnek 2: use Anahtar Kelimesi ile İsim Alanı İçe Aktarma
use anahtar kelimesi, tam nitelikli isimleri (FQN) kısaltmak ve kodu daha okunabilir hale getirmek için kullanılır.
log("Uygulama başlatıldı.");
$notifier = new EmailNotifier();
$notifier->notify("Yeni bir kullanıcı kaydoldu.");
$dbConn = new DbConnection(); // Takma ad ile kullanım
?>Çıktı:
Dosyaya loglandı: Uygulama başlatıldı.
E-posta ile bildirildi: Yeni bir kullanıcı kaydoldu.
Veritabanı bağlantısı oluşturuldu (App\Database).Örnek 3: İsim Alanı İçinde Global Fonksiyonlara Erişim
Bir isim alanı içinden global isim alanındaki bir fonksiyona veya sınıfa erişmek için \ öneki kullanılır.
format('Y-m-d H:i:s') . PHP_EOL;
// Helper sınıfı üzerinden fonksiyonu çağırma
echo "Rastgele Dize: " . Helper::generateRandomString(15) . PHP_EOL;
?>Çıktı:
Şu anki zaman (global): 2023-10-27 10:30:00 (Örnek tarih ve saat)
Rastgele Dize: aBcD1eF2gH3iJ4k (Örnek çıktı)Tek Dosya, Tek İsim Alanı: Genel kabul gören pratik, her PHP dosyasında yalnızca bir isim alanı bildirimi yapmaktır. Bu, kodun okunabilirliğini ve otomatikle yükleme (autoloading) mekanizmalarının düzgün çalışmasını sağlar.
PSR-4 Standardı: PHP topluluğu tarafından önerilen PSR-4 autoloading standardı, isim alanlarının dosya sistemi yapısıyla eşleşmesini teşvik eder. Örneğin, App\Database\Connection isim alanındaki bir sınıf genellikle src/App/Database/Connection.php yolunda bulunur.
Global Fonksiyonlara Erişim: Bir isim alanı içinde global bir fonksiyona veya sınıfa (örneğin strlen() veya DateTime) erişmek için başına \ koyarak tam nitelikli yolunu belirtmek iyi bir pratiktir (örneğin \strlen()). Bu, isim alanınızda aynı isimde bir fonksiyon veya sınıf tanımlandığında oluşabilecek belirsizliği önler.
use Bildiriminin Kapsamı: use bildirimleri, sadece tanımlandıkları dosya içinde geçerlidir ve mevcut isim alanını etkilemez. Her dosya için ayrı ayrı use bildirimleri yapılmalıdır.
İsim Alanı Gruplama Kullanımı: PHP 7'den itibaren, aynı kök isim alanına sahip birden fazla sınıfı veya fonksiyonu tek bir use bildirimi ile içe aktarmak mümkündür (örneğin, use App\Module\{ClassA, ClassB, FunctionC};).
Sınıf Adı Çakışmaları: İki farklı kütüphaneden gelen aynı isimli sınıfları kullanmanız gerektiğinde, use anahtar kelimesi ile as takma adını kullanarak çakışmaları çözebilirsiniz (örneğin, use MyVendor\Utility\Logger as MyLogger;).
PHP, sunucu taraflı betik dili olarak, program akışını yönetmek için çeşitli denetim yapıları sunar. Bu yapılar, belirli koşullara bağlı olarak kod bloklarının yürütülmesini veya belirli işlemlerin tekrar tekrar gerçekleştirilmesini sağlar. Denetim yapıları, herhangi bir programlama dilinin temelini oluşturur ve uygulamanızın mantıksal akışını şekillendirmenize olanak tanır. Bu makale, PHP'deki temel denetim yapılarının nasıl kullanılacağını, sözdiziminden pratik örneklere kadar adım adım açıklayacaktır.
PHP'de yaygın olarak kullanılan denetim yapılarının temel sözdizimi aşağıda listelenmiştir:
// If-Else If-Else Yapısı
if (koşul_1) {
// koşul_1 doğru ise çalışacak kod bloğu
} elseif (koşul_2) {
// koşul_1 yanlış ve koşul_2 doğru ise çalışacak kod bloğu
} else {
// tüm koşullar yanlış ise çalışacak kod bloğu
}
// Switch Yapısı
switch (ifade) {
case değer_1:
// ifade, değer_1'e eşit ise çalışacak kod bloğu
break;
case değer_2:
// ifade, değer_2'ye eşit ise çalışacak kod bloğu
break;
default:
// hiçbir case ile eşleşmezse çalışacak kod bloğu
break;
}
// While Döngüsü
while (koşul) {
// koşul doğru olduğu sürece çalışacak kod bloğu
}
// Do-While Döngüsü
do {
// kod bloğu en az bir kez çalışır, sonra koşul kontrol edilir
} while (koşul);
// For Döngüsü
for (başlangıç; koşul; artırma/azaltma) {
// koşul doğru olduğu sürece ve her döngüde artırma/azaltma ile çalışacak kod bloğu
}
// Foreach Döngüsü
foreach ($dizi as $değer) {
// her dizi elemanı için çalışacak kod bloğu
}
// Foreach Döngüsü (Anahtar ve Değer ile)
foreach ($dizi as $anahtar => $değer) {
// her dizi elemanı için anahtar ve değer ile çalışacak kod bloğu
}
// Döngü Kontrol Anahtar Kelimeleri
// break: mevcut döngüyü tamamen sonlandırır
// continue: mevcut iterasyonu atlar ve bir sonraki iterasyona geçer
Her bir denetim yapısı, belirli bir amaca hizmet eder ve programınızın mantıksal akışını farklı şekillerde yönetir:
if, else if, else: Bu yapılar, belirli bir koşulun doğruluğuna göre farklı kod bloklarını çalıştırmak için kullanılır. if ifadesi, ana koşulu kontrol eder. Eğer bu koşul yanlışsa, isteğe bağlı olarak bir veya daha fazla else if ifadesi ek koşulları kontrol eder. Hiçbir koşul doğru olmazsa, isteğe bağlı else bloğu yürütülür.
switch: Tek bir ifadenin farklı olası değerlerine göre farklı kod bloklarını yürütmek için kullanılır. Her bir case bloğu, ifadenin belirli bir değerle eşleşip eşleşmediğini kontrol eder. break anahtar kelimesi, eşleşen bir case bulunduğunda switch bloğundan çıkılmasını sağlar. default bloğu, hiçbir case ile eşleşme olmadığında çalışır.
while: Belirtilen bir koşul doğru olduğu sürece bir kod bloğunu tekrarlamak için kullanılır. Koşul, döngü bloğu yürütülmeden önce kontrol edilir. Eğer koşul başlangıçta yanlışsa, döngü bloğu hiç çalışmayabilir.
do-while: while döngüsüne benzer, ancak kod bloğu en az bir kez yürütülür, ardından koşul kontrol edilir. Bu, kod bloğunun her zaman en az bir kez çalışmasını garanti eder.
for: Belirli sayıda tekrar yapılması gereken durumlarda kullanılır. Üç bölümden oluşur: başlangıç ifadesi (döngü başlamadan önce bir kez çalışır), koşul ifadesi (her iterasyon öncesi kontrol edilir) ve artırma/azaltma ifadesi (her iterasyon sonrası çalışır).
foreach: Özellikle diziler ve nesneler üzerinde kolayca yineleme yapmak için tasarlanmıştır. Dizinin her elemanı için bir kez döngü yapar, elemanın değerini (ve isteğe bağlı olarak anahtarını) bir değişkene atar.
break: İçinde bulunduğu döngüyü (for, while, do-while, foreach) veya switch ifadesini anında sonlandırır ve kontrolü döngüden veya switch bloğundan sonraki ifadeye aktarır.
continue: İçinde bulunduğu döngünün mevcut iterasyonunu atlar ve döngünün bir sonraki iterasyonuna geçer. Koşul kontrolü veya artırma/azaltma işlemi normal şekilde devam eder.
Aşağıdaki örnekler, PHP denetim yapılarının gerçek senaryolarda nasıl kullanılabileceğini göstermektedir:
Örnek 1: Notlandırma Sistemi (if-else if-else)
= 90) {
echo "Harf Notu: AA
";
} elseif ($not >= 80) {
echo "Harf Notu: BA
";
} elseif ($not >= 70) {
echo "Harf Notu: BB
";
} elseif ($not >= 60) {
echo "Harf Notu: CB
";
} else {
echo "Harf Notu: FF
";
}
?>
Örnek 2: Haftanın Günü Kontrolü (switch)
";
break;
case "Cumartesi":
case "Pazar":
echo "Bugün hafta sonu.
";
break;
default:
echo "Geçersiz gün adı.
";
break;
}
?>
Örnek 3: Sayı Sayma (for Döngüsü)
";
for ($i = 1; $i <= 5; $i++) {
echo $i . "
";
}
?>
Örnek 4: Koşul Doğru Olduğu Sürece Çalışma (while Döngüsü)
";
$sayac = 0;
while ($sayac < 4) {
echo $sayac . "
";
$sayac++;
}
?>
Örnek 5: Dizi Elemanlarını Listeleme (foreach Döngüsü)
";
foreach ($meyveler as $meyve) {
echo "- " . $meyve . "
";
}
$kullanici = [
"ad" => "Ahmet",
"soyad" => "Yılmaz",
"yas" => 30
];
echo "
Kullanıcı Bilgileri:
";
foreach ($kullanici as $anahtar => $deger) {
echo $anahtar . ": " . $deger . "
";
}
?>
Örnek 6: Döngü Kontrol Anahtar Kelimeleri (break ve continue)
";
for ($i = 1; $i <= 10; $i++) {
if ($i == 3) {
// 3'ü atla
continue;
}
if ($i == 8) {
// 8'e gelince döngüyü sonlandır
break;
}
echo $i . "
";
}
// Çıktı: 1, 2, 4, 5, 6, 7
?>
break Kullanımı: switch yapısında her case bloğunun sonunda break kullanmak önemlidir. Aksi takdirde, eşleşen case'den sonraki case'ler de koşulsuz olarak çalışmaya devam eder (fall-through davranışı).
Sonsuz Döngülerden Kaçınma: while ve for döngülerinde, koşulun bir noktada yanlış olmasını sağlayacak bir mekanizma (örneğin, bir sayacın artırılması/azaltılması) bulunduğundan emin olun. Aksi takdirde, programınız sonsuz bir döngüye girer ve kaynakları tüketir.
Üçlü Operatör (Ternary Operator): Basit if-else ifadeleri için PHP'nin üçlü operatörü (koşul ? doğru_ise_değer : yanlış_ise_değer) kullanılabilir. Bu, kodu daha kısa ve okunabilir hale getirebilir.
Doğru Yapıyı Seçmek: Hangi denetim yapısının kullanılacağına karar verirken, ihtiyacınız olan işlevselliği göz önünde bulundurun. Örneğin, belirli sayıda tekrar için for, koşul doğru olduğu sürece tekrar için while, dizi veya nesne yinelemesi için foreach daha uygundur.
Kod Girintileme: Denetim yapılarının içindeki kod bloklarını düzenli bir şekilde girintilemek, kodunuzun okunabilirliğini ve anlaşılırlığını önemli ölçüde artırır.
2025 © Tüm Hakları Saklıdır.