Klasik bir upload sınıfı kullanımı biraz kafa karıştırabilir ama basit bir yapısı var.

Kullanım örnekleri :

< ?php
$upload = Upload::factory();
$upload = Upload::factory(array('directory' => 'upload/'));
$upload = Upload::factory(array('directory' => 'upload/', 'allowed_ext' => array('zip','rar')));
$upload->save($_FILES['file']);
$upload->save($_FILES['file'],'yeni isim');
?>

görüldüğü gibi isterseniz default ayarlda kullanabilirsiniz isterseniz settings dizisin de istediğiniz bir elemanı değiştirerek de kullanabilir veya tüm ayarları değiştirerek de kullanabilirsiniz.  Ayrıca save metoduna ikinci parametre olarak da yeni bir dosya ismi verebilirsiniz. yukarıdakiler örnek için yazılmıştır satırlar birbirinden bağımsızdır

Dosya boyutu içinse kullanabileceğiniz harfler GMKB yani gigabyte megabyte kilobyte byte şeklinde örneğin 1M 1G gibi.

< ?php
 
/**
 * @author Yusuf KOÇ ( Raiden )
 * @copyright 2009 © http://ysfkc.com
 * @license Licensed under the GNU General Public License, version 2. 
 * @license the file http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
 * @version $Id: upload.class.php 1 2009-12-04 raiden $
 */
 
class Upload
{    
 
   /**
    *  @var array default upload settings
    **/
    private static $config = array(
        'directory' => 'upload',
        'allowed_ext' => array('jpg','gif','png'),
        'allowed_size' => '1M',
        'chmod' => 0644,
        'remove_spaces' => true
    );
 
   /**
    * Construct Metod
    * @param array $config 
    **/
    public function __construct($config = null)
    {
        if ($config !== null)
        {
            self::array_overwrite($config);
        }
 
        return $this;
    }
 
   /**
    * Factory of Class
    * @return object Class
    **/ 
    public static function factory($config = null)
    {   
        if ($config === null)
           return  new Upload;
        else
           return new Upload($config);
    }
 
   /**
    * Overwrite Array Value 
    * @param array $array
    **/
    private static function array_overwrite(array $array)
    {
        if (!is_array($array)) exit('Argument is not array!');
 
        foreach (array_intersect_key($array,self::$config) AS $key => $value)
        {
           self::$config[$key] = $value;
        }
    }
 
   /**
    * Upload Save
    * @param array $_FILES['name']
    * @param string New Filename
    **/    
    public function save(array $file, $filename = null)
    {
        if (!is_uploaded_file($file['tmp_name']))
        {
            return false;
        }
 
        if (is_null($filename))
        {
            $filename = uniqid().$file['name'];
        }
 
        if (self::$config['remove_spaces'] == true)
        {
            $filename = preg_replace('#\s+#','_',$filename);
        }
 
        if ($this->check_directory() === false)
        {
            exit(realpath(self::$config['directory']).' is not writable');
        }
 
        if ($this->check_allowed_ext($file['name']) === false) 
        {
            exit('The file extension is not valid. Allowed Extension: '.implode(', ',self::$config['allowed_ext']));
        }
 
        if ($this->check_allowed_size($file,self::$config['allowed_size']) === false)
        {
            exit('Maximum file size exceeded. Allowed Size: '.self::$config['allowed_size']);
        }
 
        $filePath = realpath(self::$config['directory']).DIRECTORY_SEPARATOR.$filename;
 
        if (move_uploaded_file($file['tmp_name'],$filePath))
        {
            if (self::$config['chmod'] !== null)
            {
                chmod($filePath,self::$config['chmod']);
            }
 
            return $filePath;
        }
 
        return false;
    }
 
   /**
    * Check Directory (is_dir or is_writable)
    * @return bool 
    **/    
    private function check_directory()
    {
        if (is_dir(realpath(self::$config['directory'])) || is_writable(realpath(self::$config['directory'])))
        {
            return true;
        }
 
        return false;
    }
 
   /**
    * Check File Extension
    * @return bool 
    **/        
    private function check_allowed_ext($file)
    {
        if (in_array(pathinfo($file,PATHINFO_EXTENSION),self::$config['allowed_ext']))
        {
            return true;
        }
 
        return false;
    }
 
   /**
    * Check File Size
    * @copyright http://www.kohanaphp.com
    * @param array $_FILES['name']
    * @param string File Size
    * @return bool 
    **/    
    private function check_allowed_size($file,$size)
    {
        if (!preg_match('#[0-9]++[GMKB]#',$size))
        {
            return false;
        }
 
        switch (substr($size,-1))
        {
            case 'G': $size = intval($size) * pow(1024,3); break;
            case 'M': $size = intval($size) * pow(1024,2); break;
            case 'K': $size = intval($size) * pow(1024,1); break;
            default : $size = intval($size);                break;
        }
 
        return ($file['size'] < = $size);
    }
}
?>

Sevgiyle kalın..

Public Özelliği
Öncelikle public özelliğine değinelim. Public özelliği atanan bir değişken veya metot kullanıcı tarafından erişilebilir olmaktadır. Aynı zamanda sınıf içerisinden veya türeyen bir sınıf içersinden de erişebilir.

Hemen bir örnekle daha da pekiştirelim.

< ?php
class a
{
    public $isim = 'yusuf';
 
    public function isimGetir()
    {
        echo $this->isim;
    }
}
 
$a = new a;
echo $a->isim;
echo '<br />';
$a->isimGetir();
?>

Yukarıdaki örnekte hem bir değişkene public özelliğini hem de bir metoda public özelliğini atadık. Public ve diğer özellikler değişken veya metotdan önce başına yazılır örnektede görüldüğü gibi.

$a ve isimGetir() e public özelliği atandığı için sınıf başlatarak a classındaki bu değerlere erişme hakkına sahip olduk.

Protected Özelliği
Protected özelliği atanan bir değişken veya metot ise sadece sınıf içerisinden veya türetilen bir sınıf içerisinden erişim hakkına izin verir. Yani kullanıcı başlattığı sınıf içindeki protected tanımlı değişken veya metotlara asla erişemez.

Örnekle devam edelim.

< ?php
class a
{
    protected $isim = 'yusuf';
 
    public function isimGetir()
    {
        echo $this->isim;
    }
}
 
$a = new a;
echo $a->isim;
echo '<br />';
$a->isimGetir();
?>

Yukarıdaki örneği çalıştırdığımızda ekrana “Cannot access protected property..” diye hata çıktısı verecektir. Bunun sebebi classı başlatıp ardından da protected özelliği atanmiş değişkeni çağırmak istememizden dolayıdır. Ancak echo $a->isim; satırını silersek ekrana bu sefer $isim içeriğini yazacaktır.

Neden hata vermiyor gibi bir düşünce gelebilir aklınıza ama ne demiştik protected veya private tanımlı bir değişken veya metot sadece sınıfın kendi içinden çağrılabilir dolayısıyla public tanımlanmış isimGetir() metodu sınıfın içinde olduğu için $isim değişkenine bu metot sayesinde erişmiş oluyoruz. Böylece classı kullanacakların classı olumsuz etkilemesinden korumuş oluyoruz.

Private Özelliği
Private özelliği de işleyiş olarak protected a benzese de aslında protected tek farkı türetilen bir classdan erişim hakkı yapamaz. Bu da demek oluyor ki private özelliği atanan değişken veya metot sadece o sınıf için özel olmuş oluyor. Hiç bir şekilde classı kullanmak isteyen ziyaretçi veya türeyen bir sınıf bu değişken veya metota erişim yapamaz.

Örnekle devam edelim

< ?php
class a
{
    private $isim = 'yusuf';
 
    public function isimGetir()
    {
        echo $this->isim;
    }
}
 
$a = new a;
echo $a->isim;
echo '<br />';
$a->isimGetir();
?>

Yukarıdaki örnekte bu sefer $isim değişkenine private özelliğini atadık. Sınıf başlatılıp ardından $isim değişkenini çağırdığımızda ekranda “Cannot access private property..” gibi bir hata ile karşılaşarız. Çünkü $isim değişkeni sadece o sınıf için özel bir değişken. Hiç bir şekilde dışarıdan ( kullanıcı tarafından ) veya türetilen sınıftan erişim sağlanamaz.

Böylelikle türetilen classların da buna etki edebilerek mevcut classın işleyişinin bozulması önlenmiş olur.

Static özelliği
Static özelliği atanmış bir değişken veya metot ramde saklanır. Böylece sürekli sürekli çağrılarak ramden çalmak yerine bir defaya mahsus rame atılarak performans kaybı önlenmiş olur. Static özelliğini herşeye atamakta doğru değildir. Zira projede kullanılacak sabit değişken veya metota atamak doğrudur. Çünkü bunlar hep aynı sonucu döndürecekleri için bir defaya rame aktarılması bize performans açısından büyük hız getirecektir.

Ayrıca static özelliği atanmış bir değişken veya metoda sınıf içerisinde $this yerine self:: ile erişim sağlanmaktadır.

Örnekle devam edelim.

< ?php
class a
{
    private static $isim = 'yusuf';
 
    public static function isimGetir()
    {
        echo self::$isim;
    }
}
 
a::isimGetir();
?>

Bu örnekte de isimGetir metoduna hem public ( dışarıdan erişim yapma özelliği ) hem de static özelliği atanmıştır. Burda tek fark olarak normalde sınıfı başlatmamız gerekirdi ancak isimGetir metodu static olduğu için direk olarak erişim yapabiliriz. Buna değişkenlerde dahil.

Dışarıdan erişim yaparken sınıfadi::metot veya değişken şeklinde erişim yapabiliriz. a::isimGetir() diyerek a classının isimGetir() metoduna direk erişim yaptık ve static metodumuzu çağırdık böylece artık rame atıldı veya bundan sonraki her çağrılmasında artık bize ramden dönerek performans artışı sağlamış olacaktır.

Const Özelliği
Const özelliği atanan bir değer class içinde sabit özelliğini alır. Bu bizim normal kodlarımızdaki define() metodu ile aynıdır fakat sadece class içinde geçerlidir. Const özelliği atanmış bir sabite $this ile değil yine self:: ile erişim yapmaktayız dolayısıyla static özelliğini alırlar çünkü sınıf boyunca sakladıkları değer aynı kalacağından bir defaya mahsus ram de tutulurlar.

Ayrıca const özelliği atanan sabitin başında $ işareti bulanamaz. const sabit = ‘deger’; şeklinde tanımlanırlar.

Örnekle devam edelim.

< ?php
class a
{
    const isim = 'yusuf';
 
    public function isimGetir()
    {
        echo self::isim;
    }
}
 
 
$a = new a;
echo a::isim;
echo '<br>';
$a->isimGetir();
?>

Bu örnekte de görüldüğü gibi isim sabiti static özelliği de olduğu için hem a::isim; şeklinde ulaşabildik hem de sınıf içinde bir metot sayesinde ulaşabildik.

Final Özelliği
Final özelliği atanmış bir metot veya sınıf son metot veya son sınıf olduğunu işaret eder yani kendisinden sonra herhangi bir başka metot veya sınıf gelemez anlamını taşımaktadır.

Örnekle devam edelim

< ?php
class a
{
    private $isim = 'yusuf';
    public final function isimGetir() 
    { 
        echo $this->isim; 
    }
}
 
class b extends a 
{
    private $baska_isim = 'veli';
 
    public function isimGetir()
    {
        echo $this->baska_isim;
    }
}
 
$b = new b;
$b->isimGetir();
?>

Bu örnekte a classının en son metodunun isimGetir() olduğu tanımlanmıştır ve bu metotdan sonra herhangi bir metot gelemeyecektir. Yani a sınıfından türeyen bir class da hiç bir şekilde isimGetir() metodu bulunamaz çünkü isimGetir() a sınıfının final metodur ve override (yok sayılarak yeniden aynı metot yazılamaz. (tamam tercümem biraz düşük oldu ) edilemez.

Bu örnek bize metot içindi birde sınıflar bir birleri arasında türetilirken artık son sınıf olduğunu belirtmemiz gerekebilir. Bunun için de class sözcüğünün başına final anahtarı getirilir.

< ?php
class a 
{
    public function aGetir()
    {
        echo 'Ben A sınıfıyım. ';
    }
}
 
class b extends a
{
    public function bGetir()
    {
        echo 'Ben B sınıfıyım. ';
    }
}
 
final class c extends b
{
    public function cGetir()
    {
        echo 'Ben C sınıfıyım ve benden sonra başka bir sınıf bana extends edilemez. ';
    }
}
 
$c = new c;
$c->aGetir();
$c->bGetir();
$c->cGetir();
 
class d extends c 
{
    public function dGetir()
    {
        echo 'Ben D sınıfıyım.';
    }
}
 
$d = new d;
?>

Bu örnek çalıştırıldığında c classı final anahtar sözcüğü atandığı için kendisinden hiç bir şekilde sınıf türetilemeyecek ve ekrana “Class d my not inherit from final class (c)..” gibi şeklinde hata mesajı döndürecektir.

Artık yazımızın sonuna geldik bir class yazmak için temel bilgileri vermeye çalıştım. Soru ve önerileriniz için yorumları kullanabilirsiniz.

Şimdi gelelim classlara. Php ile class yazarken genelde kullanacağımız iki adet sabit metot var diyelim. Sabit dedim başka bir isim bulamadım şuan aklıma gelmiyor. Bu metotlar olmassa olmaz değil ama zamanla çok işimize yarayacak olan __construct ve __destruct metotlarıdır. Construct bir class başlatılırken yapılacak olan işleri yapmakla yükümlü olurken destruct metodu ise tam tersi sınıf sonlandığında yapılması gereken işleri yapmakla yükümlüdür.

Nerelerde kullanacağız sorusuna gelince, Bir sınıf başlatılırken belli başlı bazı ayarlar veya ek işlemler varsa bu metot içine yazılır. Destruct da ise tam tersi örneğin bir class başlarken kullanılan ayarları sıfırlamak için kullanabilirsiniz veya değişkenleri unset etmek için kullanabilirsiniz.

Örnekle devam edelim.

< ?php
class ilk_sinifim
{
    public function __construct()
    {
        echo 'Merhaba \'ilk_sinifim\' başlatıldı.';
    }
}
 
$ilk_sinifim = new ilk_sinifim;
?>

Yukarıdaki örneğimizi yazıp çalıştırdığımız da ekrana “Merhaba ‘ilk_sinifim’ başlatıldı.” şeklinde bir yazıyla karşılaşırız. Ne demiştik __construct (kurucu fonksiyon, yapılandırıcı fonksiyon) sınıf başlatılırken yapılması gereken işlemler varsa bu metotda tanımlanır ve sınıf başlatılırken bu metot içeriği otomatik çalışır demiştik.

Aynı zamanda eğer __construct metodunu kullanacaksak kesinlikle public anahtarı ile tanımlanması gerekir aksi halde protected veya private tanımlanırsa hata ile karşılaşırsınız. İsterseniz __construct metoduna sınıf başlatılırken değişken de gönderebilirsiniz.

Aynı örneği bu sefer de değişken göndererek yapalım.

< ?php
class ilk_sinifim
{
    public function __construct($name)
    {
        echo 'Merhaba {$name}, ben \'ilk_sinifim\' memnun oldum.';
    }
}
 
$ilk_sinifim = new ilk_sinifim('yusuf');
?>

Bu örnekte de sınıf başlatılırken bir $name değişkeni gönderdik. Sınıf başlatıldığında ise “Merhaba yusuf ben ‘ilk_sinifim’ memnun oldum.” yazısı çıkacaktır.

Destruct metodu ise construct metodunun tam tersidir. Sınıf sona erdiğindeki işlemleri yapar.

Bir örnekle pekiştirelim.

< ?php
class ilk_sinifim
{
    private $name;
 
    public function __construct($name)
    {
        $this->name = $name;
        echo $this->name;
    }
 
    public function __destruct()
    {
        echo 'Name değişken içeriği boşaltıldı.';
        unset($this->name);
    }
}
 
$ilk_sinifim = new ilk_sinifim('yusuf');
?>

Örnekte öncelikle dışardan erişemeyecekleri şekilde bir $name değişkeni tanımladık. Ardından __construct metoduna bir $name değişkeni göndererek sınıf içinde tanımladığımız $name değişkenine eşitledik ve ekrana yazdırdık. Ardından sınıf sonlanacağı vakit ekrana “Name değişken içeriği boşaltıldı.” yazısını yazıp sınıf içindeki $name değişkeninin içeriğini boşaltacaktır.

Destruct metoduda construct gibi public ile tanımlanmalıdır.

Soru ve görüşleriniz için yorumlar sizi bekliyor

Metotu bir örnekle açıklayıp bitirelim. Öncelikle aşağıdaki bir dizin içinde index.php ve bir de class adında dizin yaratalım ve class içerisine de a.class.php ve b.class.php diye iki adet php dosyası yaratalım.

Burdaki önemli nokta class dosyalarımıza gelişi güzel bir isim değilde bir düzen içerisinde isim vermektir. Çünkü fonksiyon belli bir düzeneğe göre eklemee yapacaktır. örneğin a.class.php dosyasını yüklerken class.b.php dosyasını yüklemeyecektir az sonra yazacağımız fonksiyon da bu düzeni siz kendinize göre oluşturabilirsiniz.

Evet dosyalarımızı oluşturduğumuza göre autoload fonksiyonumuzu yazalım.

autoload.php:

< ?php
function __autoload($classname)
{
    $include = "class/{$classname}.class.php";
    if (file_exists($include))
    {
        include_once($include);
    }
    else
    {
        exit($classname.' sınıfı yüklenemedi.');
    }
}
?>

Yukarıdaki autoload fonksiyonunu sayfamızın üstüne include ediyoruz. Daha sonra ise class dizinindeki herhangi bir sınıfı başlatmak istediğimiz de autoload devreye girerek sınıfı yüklüyor. Eğer hiç bir sınıf başlatmassanız sayfada hiç bir sınıfı dahil etmemiş olursunuz.

class/a.class.php:

< ?php
class a
{
    public function __construct()
    {
        echo 'Merhaba ben a sınıfıyım';
    }
}
?>

class/b.class.php:

< ?php
class b
{
    public function __construct()
    {
        echo 'Merhaba ben b sınıfıyım';
    }
}
?>

Yukarıda autoload fonksiyonu ile yüklenmesini istediğimiz sınıfları yazdık ve class dizinine sınıfadi.class.php şeklinde kaydettik.

Şimdide en son olarak index.php mizi yazalım ve örneğimizin çalışır halini görelim.

index.php:

< ?php
# Sayfa tipini ve karakter setini belirtelim.
header('Content-Type: text/html; charset=utf-8');
 
# Autoload fonksiyonumuzu dahil edelim.
include_once('autoload.php');
 
$a = new a;
echo '<br>';
$b = new b;
?>

Görüldüğü üzere __autoload fonksiyonu biz tek tek belirtmemize gerek kalmadan tüm sınıfları sayfamıza dahil etti. Burdan şu anlaşılmasın içinde 100 tane dosya varsa hepsini dahil etmiyor sayfanızda hangi sınıfı başlatıyorsanız o sınıfı dahil ediyor sadece.

Yazıyı noktalarken soru ve merak ettikleriniz için yorumları kullanabilirsiniz.

Decorate design pattern için bir interface tanımlayalım. Bu interface sabit bir metot içereceği için basit şekilde vereceğiz tabi siz kendinize göre oluşturabilirsiniz.

< ?php
interface isimDecorate
{
	public function __construct(isim $isim);
}
?>

yukarıdaki interface de bir yapılandırıcı metot tanımladık ve bu metota adı isim olan bir sınıfın geleceğini belirttik. Şimdi de interface için uygun bir sınıf yazalım.

< ?php
class isimDecorateClass implements isimDecorate
{
	public $isim;
 
	public function __construct(isim $isim)
	{
		$this->isim = $isim;
	}
}
?>

yukarıdaki isim sınıfımızı mevcut arayüzümüze göre yazdık. Yapılandırıcı metoduna isim adında bir sınıfın geleceğini ve bu gelen sınıfı da isimDecorate sınıfımızın içindeki publictanımlı $isim e aktaracağız.

Şimdide isim sınıfımızı tanımlayalım.

< ?php
class isim
{
	private $ad;
	private $soyad;
 
	public function adTanimla($ad)
	{
		$this->ad = $ad;
		return $this;
	}
 
	public function soyadTanimla($soyad)
	{
		$this->soyad = $soyad;
		return $this;
	}
 
	public function adVeSoyadGetir()
	{
		echo 'Adınız: '.$this->ad.' Soyadınız: '.$this->soyad;
	}
}
?>

Mevcut sınıflarımızı artık hazırladığımıza göre şimdi ise nasıl kullanacağız ona görelim.

< ?php
$isim = new isim;
$isim->adTanimla('yusuf');
$isim->soyadTanimla('koç');
 
$isimDecorate = new isimDecorateClass($isim);
$isimDecorate->isim->adVeSoyadGetir();
?>

Evet görüldüğü üzere önce isim sınıfımızı new ile başlatıp ad ve soyad tanımladıktan sonra oluşturduğumuz bu sınıfı isimDecorate içine gömdük ve isimDecorate sınıfına isim sınıfının özelliklerini katmış olduk.

Soru ve görüşleriniz için yorumları kullanabilirsiniz

< ?php
class notgetir
{
	private $isim;
	private $not;
 
	public function isim($isim)
	{
		$this->isim = $isim;
		return $this;	
	}
 
	public function not($not)
	{
		$this->not = $not;
		return $this;
	}
 
	public function getir()
	{
		echo $this->isim.' \'nin Notu: '.$this->not;
	}
 
	public function __clone() {}
}
?>

Yukarıda ismi ve notu belirtilen kişinin ismini ve not değerini ekrana yazan bir sınıf tanımladık. Burda yabancı olunulan metot __clone() dur. Bu metot bu sınıfın kopyalanabilir olmasını sağlar. Aslında yazmasakda kopyalanabilir ama bazen bazı durumlarda tanımlanan sınıfın kopyalanması başımıza iş açabilir o yüzden sınıfların kopyalanma özelliğini kapatmak için bu __clone() metodunu ya private yaparız ya da içine exception ya da exit ile bir uyarı mesajı koyabiliriz.

Konuyu dağıtmadan devam edelim. Şimdi biz Ali için bu sınıfı çağıralım ve verilen bilgiler doğrultusunda bu bilgileri ekrana yazsın

< ?php
$not = new notgetir;
$not->isim('Ali')->not(90)->getir();
?>

yukarıda sınıfı new operatörü ile başlattık ve hangi öğrencinin notunu istiyorsak onun ismini ve notunu set edip getir metodu ile ekrana yazdırdık. Şimdide aynı işlemi Veli için yapalım.

< ?php
$not2 = new notgetir;
$not2->isim('Veli')->not(100)->getir();
?>

Şimdi yukarıda ne yaptık aynı sınıfı tekrar new operatörü ile başlattık ve ram de bir miktar daha yer kapladık ve bu da haliyle zamanla kaynak tüketimine yol açıp performansı düşürecektir.

Aynı örneği şimdide bir prototipini oluşturarak yapalım. Aslında burda yapacağımız tek işlem daha önce Ali için başlatılmış sınıfın bir kopyasını almak.

< ?php
$not2 = clone $not;
$not2->isim('Veli')->not(100)->getir();
?>

Burda clone opetörü ile daha önce başlatılan notgetir sınıfının bir prototipini aldık yani kopyaladık böylelikle tekrar sınıfı başlatmaktan kurtulmuş olduk.

Bazılarınız $not2 = $not kısmı ile de yapılabilir bu diyebilir ama clone ile bu farklıdır. Aslında $not2 = $not demek $not2 nin $not a eşit olduğu anlamına gelir yani kopyasını almak değildir. Daha iyi anlayabilmek için aşağıdaki örneğe bakabilirsiniz.

< ?php
$not = new notgetir;
$not->isim('Ali')->not(90)->getir();
 
$not2 = $not;
$not2->getir();
 
$not3 = clone $not;
$not3->getir();
?>

Burda not2 $nota eşitleniyor ve getir metodu çağrıldığında ekrana Ali’nin notu 90 yazarken $not3 ile yine getir metodu çağrıldığında ekrana hiç bişey yazmayacaktır. Çünkü biz not3 değişkenine $not un kopyasını aldık.

Hasta halimle bu kadar bahsedebildim. Anlam bozukluğu veya anlayamadığınız yerler var ise çekinmeden sorabilirsiniz.

< ?php
class factory
{
	const class_dir = 'classes';
	public static function load($class)
	{
		try
		{
			if (file_exists(self::class_dir.'/'.$class.'.class.php'))
			{
				include_once(self::class_dir.'/'.$class.'.class.php');
				return new $class();
			}
			else
			{
				throw new Exception('Class Bulunamadı.');
			}			
		}
		catch (Exception $e)
		{
			echo $e;
		}
	}
}
?>

Yukarıda tanımladığımız factory class bize belirtilen classın class_dir dizininde olup olmadığına bakarak eğer varsa bize başlatarak dönecektir eğer yok ise catch bloğu çalışarak class bulunamadı hatasını verecektir. Ayrıca yukarıdaki sınıfa göre sınıflar class_dir dizininde ve dosya adları da abc.class.php şeklinde olduğu varsayılmıştır.

Şimdi gelelim iki tane sınıf yazalım. Birtanesi girilen ismi yazsın diğer ise sadece soyadını yazsın. Örnekleri basit tutuyorum ki anlaşılabilsin diye sonra demeyin isim ve soyisimden başka bişey bilmiyor musun be adam sen diye

< ?php
class name 
{
	public function getName($name)
	{
		echo $name;
	}
}
?>

Şimdide soyisim sınıfımızı tanımlayalım

< ?php
class surname 
{
	public function getSurname($surname)
	{
		echo $surname;
	}
}
?>

Bu classları class_dir dizinine name.class.php ve surname.class.php olarak kaydettiğinizi varsayıyorum ve factory sınıfımızın kullanımına geçiyorum

< ?php
include_once('class_dir/factory.class.php');
$isim = factory::load('name');
$isim->getName('yusuf ');
 
$surname = factory::load('surname');
$surname->getSurname('koç');
?>

Yukarıda öncelikle factory sınıfımızı sayfamıza dahil ediyoruz ve ardından artık bize hangi sınıf gerekiyorsa onu factory sınıfımıza bildiriyoruz. Eğer sınıf belirtilen dizin içinde mevcutsa bize sınıfı başlatıp döndürüyor değil ise hata veriyor.

Bunun bize faydası sınıfları daha tertipli ve düzenli bir şekilde başlatma olanağı sağlıyor ve tek bir arayüz üzerinden istediğimiz değişikliğe gitmemize olanak sağlıyor.

Şöyle bir örnek verirsek sanırım daha iyi anlaşılacaktır. Farzedelim ki sınıflarınızı sayfalarınıza hep require veya include ile çağırdınız ve bir süre sonra sınıfları bir dizinde topladınız veya dizin adını değiştirdiniz. Ne yapmak lazım şimdi? Tüm sayfaları açıp require veya include satırlarını düzeltmek lazım. Ama eğer bunu factory pattern olarak düşünüp yazsaydık sadece factory classımızda değişiklik yaptığımızda tüm sitemizde uygulanmış olacaktı.

Umarım bişeyler aktarabilmişimdir.

Adapter patterni şöyle izah edebiliriz bir düşüneyim ımmm bir firmada çalışan bir a elemanı var bu a elemanı bir proje geliştirmiş ve işten bir süre sonra ayrılmış daha sonra ise işe siz başlamışsınız ve o projeye ek bişeyler yapmanız isteniyor ancak a elemanı kendine göre yazdığı için ufak bir kod değişikliği demek tüm projeyi baştan sona kontrol etmek anlamına geldiği için iş biraz sıkıcı ve yorucu olacaktır. Adapter pattern ile mevcut koda ( interface, abstract class ) extends ederek türetilen yeni bir interface veya abstract class yaparak mevcut projeyi bozmadan işimizi kolay halletme yoludur diyebiliriz. Örnek vermek istedim çünkü böyle daha kolay anlaşılır diye düşündüm.

Şimdi bizim a elemanı ne yapmış olsun bir tane interface tanımlasın ve bu interface sadece girilen ismi ekrana yazdırmak için kullanılan bir arayüz olsun aşağıdaki gibi

< ?php
interface isim
{
	public function getName($name);
}
?>

Bu arayüze (interface) uygun sınıfınıda yazmış olsun.

< ?php
class name implements isim
{	
	public function getName($name)
	{
		echo $name;
	}
}
?>

Evet a elemanı tasarladığı arayüz üzerine sınıfınıda yazmış oldu. Ama hiç bir zaman kendisinin işi bırakacağını ve kendisinden sonra gelen birisinin buna ekleme yapması ihtimalini düşünmeyerek kodunu tamamladı. Derken işi bıraktı biz başladık işe ve bizim bu arayüze eklemeler yapmamız gerekti. Ancak arayüzü değiştirirsek bu sefer ona bağlı tüm classlarıda yeniden düzenlemek zorunda kalacağız. Çünkü arayüzle birleştirilmiş class birleştiriliği arayüz ile birebir aynı olmak zorundadır.

Yani biz tutupda arayüzü şu hale getiremeyiz.

< ?php
interface isim
{
	public function getName($name);
	public function getData();
}
?>

Bu şekile çevrilirse arayüz buna bağlı olan tüm classlar hata verecek ve işin içinden çıkılmaz bir hal alacaktır. Peki o zaman ne yapacağız mevcut yapıyı bozmadan nasıl kendi istediğimiz özellikleri bu isim arayüzüne ekleyeciz ? Classlar nasıl ki extends ile nasıl türetiliyor ise arayüzlerde bu şekilde türetilmektedir.

Derken biz bu arayüze bir metot daha tanımlamamız gerekti bu da ne olsun getSurname() metodu olsun yani girilen bir soyadını ekrana yazsın. Ama bunu yaparkende mevcut classları bozmasın.

Bunun içinde arayüzden arayüz türeteceğiz

< ?php
interface yeni_isim extends isim
{
	public function getSurname($surname);
}
?>

Hemen buna uygun sınıfımızı da yazalım

< ?php
class new_name implements yeni_isim
{	
	public function getName($name)
	{
		echo $name;
	}
 
	public function getSurname($surname)
	{
		echo $surname;
	}
}
?>

Evet herşey bu kadar. Yeni sınıfımızı istediğimiz arayüze kolayca adapte etmiş olduk. Bir kaç açıklama daha yapmak gerekirse Name Classı sadece getName() metodunu çalıştırır getSurname() metoduna erişim yapamaz ancak New_Name Classı ise hem getName() hem de getSurname() metotlarına ulaşabilir çünkü yeni_isim arayüzünden türetildiği için getSurname() metodunu barındırmak zorunda kaldı yeni_isim de isim arayüzünden türetildiği için aynı zamanda getName() metodunu da barındırmak zorunda kaldı.

Örnek kullanımlarını da gösterelim daha anlaşılır olsun.

< ?php
$name = new name;
$name->getName('yusuf');
$name->getSurname('koç'); // Php Hata verecektir.
 
$new_name = new new_name;
$new_name->getName('yusuf');
$new_name->getSurname('koç');
?>

Görüldüğü üzere Adapter Pattern bu kadar.

Kısa bir  RemoveXSS fonksiyonunu tanıtacağım zira kendiside çok basit ve etkili bir fonksiyon ve bir çok  xss den kurtulmanıza olanak sağlıyor.

function RemoveXSS($val) {
   $val = preg_replace('/([\x00-\x08,\x0b-\x0c,\x0e-\x19])/', '', $val);
   $search = 'abcdefghijklmnopqrstuvwxyz';
   $search .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
   $search .= '1234567890!@#$%^&*()';
   $search .= '~`";:?+/={}[]-_|\'\\';
   for ($i = 0; $i < strlen($search); $i++) {
      $val = preg_replace('/(&#[xX]0{0,8}'.dechex(ord($search[$i])).';?)/i', $search[$i], $val); // with a ;
      $val = preg_replace('/(&#0{0,8}'.ord($search[$i]).';?)/', $search[$i], $val); // with a ;
   }
 
   $ra1 = Array('javascript', 'vbscript', 'expression', 'applet', 'meta', 'xml', 'blink', 'link', 'style', 'script', 'embed', 'object', 'iframe', 'frame', 'frameset', 'ilayer', 'layer', 'bgsound', 'title', 'base');
   $ra2 = Array('onabort', 'onactivate', 'onafterprint', 'onafterupdate', 'onbeforeactivate', 'onbeforecopy', 'onbeforecut', 'onbeforedeactivate', 'onbeforeeditfocus', 'onbeforepaste', 'onbeforeprint', 'onbeforeunload', 'onbeforeupdate', 'onblur', 'onbounce', 'oncellchange', 'onchange', 'onclick', 'oncontextmenu', 'oncontrolselect', 'oncopy', 'oncut', 'ondataavailable', 'ondatasetchanged', 'ondatasetcomplete', 'ondblclick', 'ondeactivate', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'onerror', 'onerrorupdate', 'onfilterchange', 'onfinish', 'onfocus', 'onfocusin', 'onfocusout', 'onhelp', 'onkeydown', 'onkeypress', 'onkeyup', 'onlayoutcomplete', 'onload', 'onlosecapture', 'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onmove', 'onmoveend', 'onmovestart', 'onpaste', 'onpropertychange', 'onreadystatechange', 'onreset', 'onresize', 'onresizeend', 'onresizestart', 'onrowenter', 'onrowexit', 'onrowsdelete', 'onrowsinserted', 'onscroll', 'onselect', 'onselectionchange', 'onselectstart', 'onstart', 'onstop', 'onsubmit', 'onunload');
   $ra = array_merge($ra1, $ra2);
 
   $found = true;
   while ($found == true) {
      $val_before = $val;
      for ($i = 0; $i < sizeof($ra); $i++) {
         $pattern = '/';
         for ($j = 0; $j < strlen($ra[$i]); $j++) {
            if ($j > 0) {
               $pattern .= '(';
               $pattern .= '(&#[xX]0{0,8}([9ab]);)';
               $pattern .= '|';
               $pattern .= '|(&#0{0,8}([9|10|13]);)';
               $pattern .= ')*';
            }
            $pattern .= $ra[$i][$j];
         }
         $pattern .= '/i';
         $replacement = substr($ra[$i], 0, 2).'<x>'.substr($ra[$i], 2);
         $val = preg_replace($pattern, $replacement, $val);
         if ($val_before == $val) {
            $found = false;
         }
      }
   }
   return $val;
}

Evet üstteki fonksiyonumuz ile kullanıcılardan alınan verileri geçirdiğimizde gönül rahatlığıyla verileri ekleyebilir veya listeleyebiliriz.

Kullanımına bir örnek vererek yazımızı noktalaylım.

$veri = ' Ali Veli Deli <img src="javascript:alert(\'XSS\');"/>';
echo RemoveXSS($veri);

Dediğimizde çıktısı aşağıdaki gibi olacaktır.

 Ali Veli Deli <img src="ja<x>vasc<x>ript:alert('XSS');" />

Görüldüğü üzere javascript kelimesinin arasına ekleyerek olası XSS açığına karşı veriyi güvenli hale getirdi.