├── OOP
    ├── arayuz.php
    ├── arayuz2.php
    ├── gorunurluk.php
    ├── kalitim.php
    ├── kalitimornek.php
    ├── kurucuyikici.php
    ├── namespace
    │   └── uygulama
    │   │   ├── controller
    │   │       └── bildirimler.php
    │   │   ├── helper
    │   │       └── bildirimler.php
    │   │   └── index.php
    ├── sabit.php
    ├── sinif.php
    ├── soyutlama.php
    ├── staticdeyimi.php
    └── staticornek.php
├── PDO
    ├── baglan.php
    ├── formInsert.php
    ├── formUpdate.php
    ├── guncelle.php
    ├── header.php
    ├── homepage.php
    ├── index.php
    ├── insert.php
    ├── kategori.php
    ├── kategori_ekle.php
    ├── kategoriler.php
    ├── oku.php
    └── sil.php
└── README.md


/OOP/arayuz.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | //arayüz interface deyimi kullanılarak tanımlanır.
 4 | interface Islem
 5 | {
 6 |     public function Olustur($tabloAdi,$id);
 7 |     public function Oku($tabloAdi,$id);
 8 |     public function Guncelle($tabloAdi,$veri,$id);
 9 |     public function Sil($tabloAdi,$id);
10 | }
11 | 
12 | interface VT
13 | {
14 |     public function baglan($host,$dbname,$kadi,$sifre);
15 | }
16 | 
17 | //arayüzümü kullanmak için sınıfıma implement etmem gerekir.
18 | class VeriTabani implements Islem,VT
19 | {
20 |     public function baglan($host,$dbname,$kadi,$sifre)
21 |     {
22 | 
23 |     }
24 | 
25 |     public function Olustur($tabloAdi,$id)
26 |     {
27 | 
28 |     }
29 |     public function Oku($tabloAdi,$id)
30 |     {
31 | 
32 |     }
33 |     public function Guncelle($tabloAdi,$veri,$id)
34 |     {
35 |         
36 |     }
37 |     public function Sil($tabloAdi,$id)
38 |     {
39 | 
40 |     }
41 | }
42 | 
43 | ?>


--------------------------------------------------------------------------------
/OOP/arayuz2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | interface Islem
 4 | {
 5 |     public function Olustur($tabloAdi,$id);
 6 |     public function Oku($tabloAdi,$id);
 7 |     public function Guncelle($tabloAdi,$veri,$id);
 8 |     public function Sil($tabloAdi,$id);
 9 | }
10 | 
11 | //burada farklı olarak VT arayüzü Islem arayüzünden türetildi 
12 | interface VT extends Islem
13 | {
14 |     public function baglan($host,$dbname,$kadi,$sifre);
15 | }
16 | 
17 | //ve sadece VT arayüzü implemente edildi
18 | class VeriTabani implements VT
19 | {
20 |     public function baglan($host,$dbname,$kadi,$sifre)
21 |     {
22 | 
23 |     }
24 | 
25 |     public function Olustur($tabloAdi,$id)
26 |     {
27 | 
28 |     }
29 |     public function Oku($tabloAdi,$id)
30 |     {
31 | 
32 |     }
33 |     public function Guncelle($tabloAdi,$veri,$id)
34 |     {
35 |         
36 |     }
37 |     public function Sil($tabloAdi,$id)
38 |     {
39 | 
40 |     }
41 | }
42 | 
43 | 
44 | ?>


--------------------------------------------------------------------------------
/OOP/gorunurluk.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | error_reporting(E_ALL);
 4 | ini_set('display_errors',true);
 5 | 
 6 | class Test
 7 | {
 8 |     public $a = 'a'; //her yerden erişilebilir.
 9 | 
10 |     private $b = 'b'; //sadece sınıf içerisinden erişilebilir
11 | 
12 |     public function geriDonB()
13 |     {
14 |         return $this->b; //private özelliği public metotta geriye döndürebilirim
15 |     }
16 | 
17 |     protected $c = 'c';
18 |     //korumalı, aynı private gibi dışarıdan erişilemez sınıf içinde erişilebilir, miras aldığımız sınıfta da kullanabiliriz
19 | 
20 |     private function geriDonA() //private func
21 |     {
22 |         return $this->a;
23 |     }
24 | 
25 |     protected function geriDonC() //protected func
26 |     {
27 |         return $this->c;
28 |     }
29 | 
30 | }
31 | 
32 | $test = new Test;
33 | 
34 | echo $test->a; //bu özelliği rahatça ekrana basabildim
35 | 
36 | echo $test->b; //bu özelliği ekrana bastırmak istediğimde hata ile karşılaşıyorum
37 | 
38 | echo $test->geriDonB();
39 | 
40 | echo $test->c; //hata
41 | 
42 | echo $test->geriDonA(); //hata
43 | 
44 | echo $test->geriDonC(); //hata
45 | 
46 | ?>


--------------------------------------------------------------------------------
/OOP/kalitim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Test
 4 | {
 5 |     public $isim = 'melih';
 6 |     protected $soyisim = 'celik';
 7 |     public function selam()
 8 |     {
 9 |         return "selam";
10 |     }
11 | }
12 | 
13 | //Test2 sınıfı Test sınıfından türetildi
14 | class Test2 extends Test
15 | {
16 |     //Test sınıfının public ve protected metotlarını miras aldı
17 |     public function arkadaslar()
18 |     {
19 |         return "arkadaşlar";
20 |     }
21 | 
22 |     public function isimDon()
23 |     {
24 |         return $this->isim;
25 |     }
26 | 
27 |     public function soyIsimDon()
28 |     {
29 |         return $this->soyisim;
30 |     }
31 | 
32 | }
33 | 
34 | $test = new Test;
35 | echo $test->selam();
36 | 
37 | echo "<br>";
38 | 
39 | $test2 = new Test2;
40 | echo $test2->selam()." ".$test2->arkadaslar();
41 | 
42 | echo "<br>";
43 | echo $test2->isimDon()." ".$test2->soyIsimDon();
44 | 
45 | ?>


--------------------------------------------------------------------------------
/OOP/kalitimornek.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Calisan
 4 | {
 5 |     public $maas;
 6 |     public $adsoyad;
 7 | 
 8 |     public function setAdSoyad($adsoyad)
 9 |     {
10 |         //sınıfın içerisindeki adsoyad dışarıdan gelen adsoyad değerine eşit olsun
11 |         $this->adsoyad = $adsoyad;
12 |     }
13 | 
14 |     public function maas($maas)
15 |     {
16 |         //sınıfın içerisinde maas dışarıdan gelen maas değerine eşit olsun
17 |         $this->maas = $maas;
18 |     }
19 | 
20 |     public function senelikMaas()
21 |     {
22 |         return ($this->maas*12).'₺';
23 |     }
24 | }
25 | 
26 | class Muhasebe extends Calisan{}
27 | 
28 | class IT extends Calisan{
29 |     public function senelikMaas()
30 |     {
31 |         return 'IT Çalışanı: '.$this->adsoyad.' senelik maaş olarak '.parent::senelikMaas();
32 |     }
33 | }
34 | 
35 | $muhasabeci = new Muhasebe;
36 | 
37 | $muhasabeci->adsoyad = 'ASDAS DSASD';
38 | $muhasabeci->maas = 4200;
39 | echo "Muhasabeci Senelik Maaşı: ".$muhasabeci->senelikMaas();
40 | 
41 | echo "<br>";
42 | 
43 | $it = new IT;
44 | $it->adsoyad = 'FFJS SFLP';
45 | $it->maas= 8500;
46 | echo $it->senelikMaas();
47 | 
48 | ?>


--------------------------------------------------------------------------------
/OOP/kurucuyikici.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class YapYik
 4 | {
 5 |     private $degisken;
 6 | 
 7 |     //parametreli kurucu metot
 8 |     public function __construct($a)
 9 |     {
10 |         $this->degisken = $a;
11 |         //bir sınıf başlatıldığında otomatik olarak çağrılacak fonksiyondur
12 |         echo $this->degisken.PHP_EOL;
13 |     }
14 | 
15 |     public function bas()
16 |     {
17 |         echo 'ekrana yazı bastım'.PHP_EOL;
18 |     }
19 | 
20 |     //yıkıcı metot
21 |     public function __destruct()
22 |     {
23 |         //bir sınıfın çalışması bittiğinde çalışacak son metottur
24 |         echo 'yıkıcı metot çalıştı'.PHP_EOL;
25 |     }
26 | 
27 | }
28 |  
29 | $nesne = new YapYik('Kurucu metot çalıştı');
30 | $nesne->bas();
31 | 
32 | ?>


--------------------------------------------------------------------------------
/OOP/namespace/uygulama/controller/bildirimler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | //namespace tanımı
 4 | namespace Uygulama\Controller;
 5 | 
 6 | //burada aslında bir isim-klasör eşleşmesi yok anlaşılır olsun diye bu formatta isimlendiriyoruz 
 7 | 
 8 | //bu Bildirimler sınıfını kullanmak için bu namespace'i kullanmam gerekecek
 9 | //bu namespace Uygulama klasörünün altındaki Controller klasörünün altındaki Bildirimler sınıfını temsil ediyor.
10 | 
11 | class Bildirimler
12 | {
13 |     public function __construct()
14 |     {
15 |         echo 'Controller İçin Bildirimler oluşturuldu!';
16 |     }
17 | }
18 | 
19 | 
20 | ?>
21 | 


--------------------------------------------------------------------------------
/OOP/namespace/uygulama/helper/bildirimler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | //namespace tanımı
 4 | namespace Uygulama\Helper;
 5 | 
 6 | //burada aslında bir isim-klasör eşleşmesi yok anlaşılır olsun diye bu formatta isimlendiriyoruz 
 7 | 
 8 | //bu Bildirimler sınıfını kullanmak için bu namespace'i kullanmam gerekecek
 9 | //bu namespace Uygulama klasörünün altındaki Helper klasörünün altındaki Bildirimler sınıfını temsil ediyor.
10 | 
11 | class Bildirimler
12 | {
13 |     public function __construct()
14 |     {
15 |         echo 'Helper İçin Bildirimler oluşturuldu!';
16 |     }
17 | }
18 | 
19 | 
20 | 
21 | ?>
22 | 


--------------------------------------------------------------------------------
/OOP/namespace/uygulama/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | require __DIR__.'/controller/bildirimler.php';
 5 | require __DIR__.'/helper/bildirimler.php';
 6 | 
 7 | //Video sınıflarını çağırmak için namespacelere göre işlem yapmam gerekir.
 8 | 
 9 | use Uygulama\Controller\Bildirimler; // use namespaceismi\sınıfismi;
10 | $controllerBildirim = new Bildirimler;
11 | 
12 | echo '<br>';
13 | 
14 | //veya şöyle bir kullanımda yapabilirim
15 | $helperBildirim = new Uygulama\Helper\Bildirimler;
16 | 
17 | ?>


--------------------------------------------------------------------------------
/OOP/sabit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class File
 4 | {
 5 | 
 6 |     const DIRECTORY = __DIR__; // __DIR__ hangi dizinde ise bize onun ismini döndürür
 7 |     public function getDirectory()
 8 |     {
 9 |         return self::DIRECTORY; //dizin yolunu geri döndürür, self(sınıfı referans alır) ile eriştim
10 |     }
11 | 
12 | }
13 | 
14 | class Folder extends File
15 | {
16 |     public function getDirectory()
17 |     {
18 |         return parent::DIRECTORY; //File sınıfındaki DIRECTORY sabitini kullandım, parent(temel sınıfı)'ı baz aldım.
19 |     }
20 | }
21 | 
22 | //File sınıfından nesne oluşturalım
23 | $file = new File;
24 | echo $file->getDirectory();
25 | 
26 | //veya sınıfı başlatmadan da sabitin değerini alabiliriz
27 | echo "<br>". File::DIRECTORY;
28 | 
29 | 
30 | //dizin değerini geri döndürme işlemini Folder sınıfının nesnesi ile yapalım
31 | $folder = new Folder;
32 | echo "<br>". $folder->getDirectory();
33 | 
34 | ?>


--------------------------------------------------------------------------------
/OOP/sinif.php:
--------------------------------------------------------------------------------
 1 | <?php 
 2 | 
 3 | class Uye
 4 | { 
 5 |     public $ad = 'Melih';
 6 |     public $soyad = 'Celik';
 7 |     const DOGUMTARIHI = 1999;
 8 |     
 9 |     //başına public koyulmaz ise varsayılan olarak public atanır
10 |     function stringAdDondur()
11 |     {
12 |         return 'Melih';
13 |     }
14 | 
15 |     public function stringSoyadDondur()
16 |     {
17 |         return 'Celik';
18 |     }
19 | 
20 |     //geriye değer döndüren parametreli fonksiyon
21 |     public function kacYasinda($gunumuz,$dogumTarihi)
22 |     {   
23 |         return $gunumuz - $dogumTarihi;
24 |     }
25 | 
26 |     //özellikleri kullanarak fonksiyon içerisinde değer geri döndürmek için $this kullanılır ve this ile yerel özelliklere erişim sağlanır.
27 |     function adDondur()
28 |     {
29 |         return $this->ad;
30 |     }
31 |     function soyadDondur()
32 |     {
33 |         return $this->soyad;
34 |     }
35 | 
36 |     //fonksiyon içerisinde fonksiyonumuzu döndürmek isteseydik
37 |     function yasBas()
38 |     {
39 |         return $this->kacYasinda(2020,$this::DOGUMTARIHI);
40 |     }
41 |     
42 |     //sabiti geriye döndürmek
43 |     function dogumTarihi()
44 |     {
45 |         return $this::DOGUMTARIHI;
46 |     }//veya self kullanabiliriz
47 |     function dogumTarihi2()
48 |     {
49 |         return self::DOGUMTARIHI;
50 |     }
51 | }
52 | 
53 | //sınıftan nesne olusturma
54 | $uye = new Uye();
55 | //veya 
56 | $uye2 = new Uye;
57 | 
58 | 
59 | //sınıf içerisindeki özelliklere ve metotlara erişmek için -> işareti kullanılır
60 | 
61 | //metotlara erişmek ve ekrana yazdırmak için
62 | echo $uye->stringAdDondur() . "<br>";
63 | 
64 | //özeliğe erişmek ve ekrana yazdırmak
65 | echo $uye->soyad . "<br>" ; //çıktı Celik
66 | 
67 | //sabite erişmek ve ekrana yazdırmak için 
68 | echo $uye::DOGUMTARIHI;
69 | 
70 | 
71 | //uye2 için özelliklere farklı değerler atayalım:
72 | $uye2->ad = 'Farklıİsim';
73 | $uye2->soyad = 'FarkliSoyad';
74 | 
75 | echo "<hr>";
76 | echo "<br>". $uye2->ad;
77 | echo "<br>". $uye2->soyad;
78 | echo "<br>". $uye2::DOGUMTARIHI;
79 | 
80 | //parametreli metodu çağırmak 
81 | echo "<hr>";
82 | echo "KAÇ YAŞINDALAR?" . "<br>";
83 | echo $uye->kacYasinda(2020,$uye::DOGUMTARIHI);
84 | 
85 | //özellik ve fonksiyonları geri döndüren fonksiyonları çağırmak
86 | echo "<hr>";
87 | echo "Birde özellikleri geri döndürerek ad ve soyadı ekrana bastıralım" . "<br>";
88 | echo $uye->adDondur() . "<br>";
89 | echo $uye->soyadDondur();
90 | echo "<br>". "Birde metodu geri döndürerek yaşı ekrana bastıralım" . "<br>";
91 | echo $uye->yasBas();
92 | 
93 | //this ve self ile sabit döndüren fonksiyonların ekrana bastırılması
94 | echo $uye->dogumTarihi(); //this kullanıldı
95 | echo $uye->dogumTarihi2(); //self kullanıldı
96 | 
97 | //this NESNEYİ REFERANS ALIR , self ise SINIFI REFERANS ALIR
98 | 
99 | ?>


--------------------------------------------------------------------------------
/OOP/soyutlama.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | abstract class Eklenti //soyut sınıf
 4 | {
 5 |     abstract public function setTitle($title); //soyut metot, gövdesi yazılmaz, zorunluluk bildirir
 6 |     abstract public function setContent($content); //soyut metot, gövdesi yazılmaz, zorunluluk bildirir
 7 |     //normal metot 
 8 |     public function show()
 9 |     {
10 |         echo '<h1>'.$this->title.'</h1>';
11 |         echo '<p>'.$this->content.'</p>';
12 |     }
13 | }
14 | 
15 | class SonYorumlar extends Eklenti //soyut sınıftan türedi
16 | {
17 |     public function setTitle($title)
18 |     {
19 |         //özelliğin tanımı metot içinde yapıldı (title)
20 |         $this->title = $title;
21 |     }
22 |     public function setContent($content)
23 |     {
24 |         //özelliğin tanımı metot içinde yapıldı (content)
25 |         $this->content = $content;
26 |     }
27 | }
28 | 
29 | class SosyalMedya extends Eklenti //soyut sınıftan türedi
30 | {
31 |     public function setTitle($title)
32 |     {
33 |         //özelliğin tanımı metot içinde yapıldı (title)
34 |         $this->title = $title;
35 |     }
36 |     public function setContent($content)
37 |     {
38 |         //özelliğin tanımı metot içinde yapıldı (content)
39 |         $this->content = $content;
40 |     }
41 | }
42 | 
43 | //SonYorumlar sınıfını başlatıyorum
44 | $sonyorumlar = new SonYorumlar;
45 | //değerleri set edelim
46 | $sonyorumlar->setTitle('Son Yorumlar');
47 | $sonyorumlar->setContent('Son Yorumlar Burada Gözükecek');
48 | 
49 | //SosyalMedya sınıfını başlatıyorum
50 | $sosyalmedya = new SosyalMedya;
51 | //değerleri set edelim
52 | $sosyalmedya->setTitle('Sosyal Medya');
53 | $sosyalmedya->setContent('Sosyal Medya Bağlantıları Burada Gözükecek');
54 | 
55 | echo $sonyorumlar->show();
56 | echo "<br>";
57 | echo $sosyalmedya->show();
58 | 
59 | ?>


--------------------------------------------------------------------------------
/OOP/staticdeyimi.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class Test
 4 | {
 5 |     public static function selam()
 6 |     {
 7 |         return 'selam';
 8 |     }
 9 | }
10 | 
11 | //içerisinde static metot olan bir sınıfımız varsa 
12 | echo Test::selam(); //new ile oluşturmadan bu şekilde metotu çağırabilirim
13 | 
14 | ?>


--------------------------------------------------------------------------------
/OOP/staticornek.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class File
 4 | {
 5 |     public static $dosyaAdi;
 6 |     public static function Olustur($dosyaAdi,$icerik)
 7 |     {
 8 |         self::$dosyaAdi = $dosyaAdi;
 9 |         $dosya = fopen($dosyaAdi,'w+');
10 |         fwrite($dosya,$icerik);
11 |         fclose($dosya);
12 |     }
13 |     public static function Oku($dosyaAdi = null)
14 |     {   
15 |         if(!$dosyaAdi) $dosyaAdi = self::$dosyaAdi; 
16 |         return file_get_contents($dosyaAdi);
17 |     }
18 | }
19 | //sınıfın örneğini oluşturmadan
20 | File::Olustur('a.txt','deneme içeriği');
21 | 
22 | $ds = new File;
23 | echo $ds->Oku();
24 | 
25 | ?>
26 | 
27 | 


--------------------------------------------------------------------------------
/PDO/baglan.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 |     try
 3 |     {
 4 |         //PDO bir sınıf olduğu için new PDO demek gerekiyor onu da bir değişkene atıyorum.
 5 |         //phpmyadmin'den veri isimli bir veritabanı oluşturduğumuzu varsayalım (utf8_general_ci).
 6 |         $db = new PDO('mysql:host=localhost;dbname=veri','root',''); //dsn,username,passwd
 7 |     }
 8 |     catch (PDOException $e)
 9 |     {
10 |         $e->getMessage();
11 |     }
12 | ?>


--------------------------------------------------------------------------------
/PDO/formInsert.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //burada veritabanına form ile ekleme işlemi yapacağız.
 3 | //veriler diye bir tablo oluşturduğumuzu varsayalım.
 4 | 
 5 | /*                                                   veriler
 6 |  *  ==================================================================================================
 7 |  * id -> int (PK) , baslik -> varchar , icerik -> text , onay -> int , tarih-> timestamp (current_timestap())
 8 |  */
 9 | 
10 | //kategoriler için
11 | $sorgu = $db -> prepare('SELECT * FROM verikategorisi ORDER BY ad ASC'); //a-z'ye sıralama
12 | $sorgu -> execute();
13 | $getir = $sorgu -> fetchAll(PDO::FETCH_ASSOC);
14 | 
15 | //form gönderilmiş.
16 | if (isset($_POST['submit']))
17 | {
18 |     $baslik = isset($_POST['baslik']) ? $_POST['baslik'] : null;
19 |     $icerik = isset($_POST['icerik']) ? $_POST['icerik'] : null;
20 |     $onay = isset($_POST['onay']) ? $_POST['onay'] : 0;
21 |     //yeni eklendi:
22 |     $kategori_id = isset($_POST['kategori_id']) ? $_POST['kategori_id'] : null;
23 | 
24 |     if (!$baslik)
25 |     {
26 |         echo "Başlık ekleyin";
27 |     }else if(!$icerik)
28 |     {
29 |         echo "İçerik ekleyin";
30 |     }else if(!$kategori_id)
31 |     {
32 |         echo "Kategori seçin!";
33 |     }else
34 |     {
35 |         //veriler tablosuna ekleme işlemi
36 |         $sorgu = $db->prepare('INSERT INTO veriler SET
37 |         baslik = ?,
38 |         icerik = ?,
39 |         onay = ?,
40 |         kategori_id = ?');
41 | 
42 |         //baslik,icerik ve onayı işlem dizisine koyuyorum.
43 |         $ekle = $sorgu -> execute([
44 |             $baslik,
45 |             $icerik,
46 |             $onay,
47 |             $kategori_id
48 |         ]);
49 | 
50 |         //eğer ekleme işlemi başarılıysa
51 |         if ($ekle)
52 |         {
53 |             //yönlendirme işlemi yapıyorum.
54 |             header('Location:index.php');
55 |         } else {
56 |             $hata = $sorgu -> errorInfo();
57 |             echo "MySQL Hatası: ".$hata[2];
58 |         }
59 | 
60 |     }
61 | 
62 | }
63 | ?>
64 | 
65 | <form action="" method="post">
66 |     Başlık: <br>
67 |     <input type="text" name="baslik" value="<?php echo isset($_POST['baslik']) ? $_POST['baslik'] : '' ?>"> <br>
68 |     <!--baslik inputu içinde yazdığım php kodu ile eğer bir submit işlemi olduysa değeri içinde tutup
69 |     yazacak ve veri kaybı olmayacak eğer zaten bir değeri yoksa input içinde boş bir string yazacak.-->
70 |     İçerik: <br>
71 |     <textarea name="icerik" cols="30" rows="10"></textarea> <br>
72 | 
73 |     Kategori: <br>
74 |     <select name="kategori_id">
75 |         <option value="">-- Kategori Seçin --</option>
76 |         <?php foreach ($getir as $gt): ?>
77 |             <option value="<?php echo $gt['id'];?>"><?php echo $gt['ad']; ?></option>
78 |         <?php endforeach; ?>
79 |     </select>
80 | 
81 |     <br>
82 | 
83 |     Onay: <br>
84 |     <select name="onay">
85 |         <option value="1">Onaylı</option>
86 |         <option value="0">Onaylı değil</option>
87 |     </select> <br>
88 |     <input type="hidden" name="submit" value="1"> <!--Gizli input değer kontrolü için-->
89 |     <br>
90 |     <button type="submit">Gönder</button>
91 | </form>
92 | 


--------------------------------------------------------------------------------
/PDO/formUpdate.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | //yeni eklendi:
  4 | $sorgugetir = $db -> prepare('SELECT * FROM verikategorisi ORDER BY ad ASC'); //a-z'ye sıralama
  5 | $sorgugetir -> execute();
  6 | $getir = $sorgugetir -> fetchAll(PDO::FETCH_ASSOC);
  7 | 
  8 | //eğer gönderilmeye çalışılan id değişkeni yoksa veya boşsa
  9 | if (!isset($_GET['id']) ||empty($_GET['id']))
 10 | {
 11 |     header('Location:index.php');
 12 |     exit;
 13 | }
 14 | 
 15 | $sorgu = $db -> prepare('SELECT * FROM veriler
 16 | WHERE id = ?');
 17 | 
 18 | //gönderilen id değerini execute et.
 19 | $sorgu -> execute([
 20 |     $_GET['id']
 21 | ]);
 22 | 
 23 | //tek bir id'yi çekeceğim için fetch()
 24 | $veri = $sorgu -> fetch(PDO::FETCH_ASSOC);
 25 | 
 26 | //eğer veri yoksa
 27 | if (!$veri)
 28 | {
 29 |     //direk index'e yönlensin.
 30 |     header('Location:index.php');
 31 |     exit;
 32 | }
 33 | 
 34 | if (isset($_POST['submit'])) {
 35 |     {
 36 |         $baslik = isset($_POST['baslik']) ? $_POST['baslik'] : $veri['baslik'];
 37 |         $icerik = isset($_POST['icerik']) ? $_POST['icerik'] : $veri['baslik'];
 38 |         $onay = isset($_POST['onay']) ? $_POST['onay'] : 0; //onay yoksa zaten 0 olsun
 39 |         //yeni eklendi:
 40 |         $kategori_id = isset($_POST['kategori_id']) ? $_POST['kategori_id'] : null;
 41 | 
 42 |         if (!$baslik) {
 43 |             echo "Başlık ekleyin";
 44 |         } else if (!$icerik) {
 45 |             echo "İçerik ekleyin";
 46 |         }else if (!$kategori_id)
 47 |         {
 48 |             echo "Kategori seçin!";
 49 |         } else {
 50 |             //UPDATE Tablo_adi SET kolon1 = değer1 WHERE kolon=değer
 51 | 
 52 |             $sorgu = $db->prepare('UPDATE veriler SET
 53 |                 baslik = ?,
 54 |                 icerik = ?,
 55 |                 onay = ?,
 56 |                 kategori_id = ?
 57 |                 WHERE id = ?'); //id'si şu olan...
 58 | 
 59 |             //sorgu değişkenimi execute ediyorum ve güncelle değişkenine atıyorum.
 60 |             $guncelle = $sorgu->execute([
 61 |                 $baslik, $icerik, $onay,$kategori_id, $veri['id']
 62 |             ]);
 63 | 
 64 |             //eğer güncelleme başarılıysa
 65 |             if ($guncelle) {
 66 |                 header('Location:index.php?sayfa=oku&id=' . $veri['id']);
 67 |             } else {
 68 |                 echo "Güncelleme işlemi başarısız!";
 69 |             }
 70 |         }
 71 |     }
 72 | }
 73 | ?>
 74 | 
 75 | <form action="" method="post">
 76 |     Başlık: <br>
 77 |     <input type="text" name="baslik" value="<?php echo isset($_POST['baslik']) ? $_POST['baslik'] : $veri['baslik'] ?>"> <br>
 78 |     <!--baslik inputu içinde yazdığım php kodu ile eğer bir submit işlemi olduysa değeri içinde tutup
 79 |     yazacak ve veri kaybı olmayacak eğer zaten bir değeri yoksa benim kendi başlık değerimi gösterecek.-->
 80 |     İçerik: <br>
 81 |     <textarea name="icerik" cols="30" rows="10"></textarea> <br>
 82 | 
 83 |     Kategori: <br>
 84 |     <select name="kategori_id">
 85 |         <option value="">-- Kategori Seçin --</option>
 86 |         <?php foreach ($getir as $gt): ?>
 87 |             <option <?php echo $gt['id'] == $veri['kategori_id'] ? 'selected' : null ?> value="<?php echo $gt['id'];?>"><?php echo $gt['ad']; ?></option>
 88 |         <?php endforeach; ?>
 89 |     </select>
 90 | 
 91 |     <br>
 92 | 
 93 |     Onay: <br>
 94 |     <select name="onay">
 95 |         <option <?php echo $veri['onay']== 1 ? 'selected' : ''  //ders onay 1'e eşitse onu seçer değilse boş olur.?> value="1">Onaylı</option>
 96 |         <option <?php echo $veri['onay'] == 0 ? 'selected' : '' ?> value="0">Onaylı değil</option>
 97 |     </select> <br>
 98 |     <input type="hidden" name="submit" value="1"> <!--Gizli input değer kontrolü için-->
 99 |     <button type="submit">Gönder</button>
100 | </form>
101 | 


--------------------------------------------------------------------------------
/PDO/guncelle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //UPDATE Tablo_adi SET kolon1 = değer1 WHERE kolon=değer
 3 | 
 4 | $sorgu = $db->prepare('UPDATE veriler SET
 5 | baslik = ?,
 6 | icerik = ?,
 7 | onay = ?
 8 | WHERE id = ?'); //id'si şu olan...
 9 | 
10 | //sorgu değişkenimi execute ediyorum ve güncelle değişkenine atıyorum.
11 | $guncelle = $sorgu->execute([
12 |     'yeni başlık','yeni içerik',1,2
13 | ]);
14 | 
15 | //eğer güncellendiyse...
16 | if ($guncelle)
17 | {
18 |     echo "Güncelleme işlemi başarılı!"; //...yazdır.
19 | }else
20 | {
21 |     echo "Güncelleme işlemi başarısız!";
22 | }
23 | 
24 | 
25 | ?>


--------------------------------------------------------------------------------
/PDO/header.php:
--------------------------------------------------------------------------------
1 | <?php include 'baglan.php' ?>
2 | <a href="index.php/">[Ana Sayfa]</a>
3 | <a href="index.php/?sayfa=kategoriler">[Kategoriler]</a>
4 | <a href="index.php/?sayfa=formInsert">[İçerik Ekle]</a>
5 | <hr>
6 | 


--------------------------------------------------------------------------------
/PDO/homepage.php:
--------------------------------------------------------------------------------
 1 | <h3>Veriler - Başlıklar</h3>
 2 | 
 3 | <!-- LIKE kullanımı anlatılırken eklendi -->
 4 | 
 5 | <form action="" method="get">
 6 |     <input type="text" name="arama" placeholder="Verilerde Arama Yap" value="<?php echo isset($_GET['arama']) ? $_GET['arama'] : '' ?>">
 7 |     <!-- Eğer arama yapılmışsa get edilen değer input text'in değeri olarak yazacak-->
 8 |     <button type="submit">ARAMA</button>
 9 | </form>
10 | 
11 | <!-- LIKE kullanımı anlatılırken eklendi -->
12 | 
13 | 
14 | <?php
15 | 
16 | //SELECT * FROM Tablo_adi
17 | //listeleme işlemi: (fetc() ~ fetchAll())
18 | 
19 | /*
20 | $sorgu = $db->prepare('SELECT * FROM veriler WHERE id=? ');
21 | $sorgu -> execute([
22 |     3
23 | ]); //veriler tablosundaki id'si 3 olanı listeler.
24 | $veriler = $sorgu->fetchAll(PDO::FETCH_ASSOC);
25 | */
26 | 
27 | /*
28 |  * verikategorisi tablosu eklenmeden önceki hali:
29 |  * $veriler = $db->query('SELECT * FROM veriler')->fetchAll(PDO::FETCH_ASSOC);
30 | */
31 | 
32 | //verikategorisi tablosu eklendikten sonraki INNER JOIN'li hali:
33 | //INNER JOIN Tablo_Adi ON Tablo_Adi.id = digerTablo_Adi.id
34 | 
35 | $sql = ' SELECT veriler.id,veriler.baslik,verikategorisi.ad as kategori_adi,veriler.onay FROM veriler
36 | INNER JOIN verikategorisi ON verikategorisi.id = veriler.kategori_id'; //sql sorgumu değişkene atadım
37 | 
38 | if (isset($_GET['arama'])) //eğer bir arama yapılmışsa
39 | {
40 |     //bu ifadeyi de sql ifademe dahil edeceğim:
41 |     $sql .= ' WHERE veriler.baslik LIKE "%' . $_GET['arama'] . '%" || veriler.icerik LIKE "%' . $_GET['arama'] . '%" ';
42 | }
43 | 
44 | //. operatörü ile ifadeleri birbirine bağlayalım
45 | $sql .= ' ORDER BY veriler.id DESC';
46 | 
47 | 
48 | $veriler = $db->query($sql)->fetchAll(PDO::FETCH_ASSOC); //son eklenen verilere göre listele
49 | 
50 | ?>
51 | 
52 | 
53 | <!--Eğer veri varsa-->
54 | <?php if ($veriler): ?>
55 |         <ul>
56 |         <!-- foreach ile veriler çekiliyor $veriler as $vr-->
57 |     <?php foreach ($veriler as $vr): ?>
58 |         <li>
59 |             <!--İçeriklerin başlıkları ve kategorileri listelendi-->
60 |             <?php echo $vr['baslik']; ?>
61 |             (<?php echo $vr['kategori_adi']; ?>)
62 |             <div>
63 |               <?php if($vr['onay'] == 1): ?>
64 |                   <!--Sadece onaylı olan içeriklerin başlıkları gösterilecek.-->
65 |                   <a href="index.php?sayfa=oku&id=<?php echo $vr['id'];?>">[OKU]</a>
66 |               <?php endif; ?>
67 |               <a href="index.php?sayfa=formUpdate&id=<?php echo $vr['id'] ?>">[DÜZENLE]</a>
68 |               <a href="index.php?sayfa=sil&id=<?php echo $vr['id'] ?>">[SİL]</a>
69 |           </div>
70 |         </li>
71 |     <?php endforeach;?>
72 |         </ul>
73 | <?php else: ?>
74 |     <div>
75 |         <!--arama var ama içerik yoksa:-->
76 |         <?php if($_GET['arama']): ?>
77 |         Aradığınız kritere uygun veri bulunamadı!
78 |         <?php else: ?>
79 |         <!--İçerik yoksada farklı bir hata mesajı:-->
80 |         Henüz eklenmiş veri bulunmuyor!
81 |         <?php endif; ?>
82 | 
83 |     </div>
84 | <?php endif; ?>
85 | 
86 | 


--------------------------------------------------------------------------------
/PDO/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | ob_start();
 4 | require_once 'header.php';
 5 | 
 6 | //LIKE kullanımı işlenirken eklendi:
 7 | $_GET = array_map(function ($get)
 8 | {
 9 |     //güvenlik önlemimiz
10 |     return htmlspecialchars(trim($get));
11 | 
12 | }, $_GET);
13 | 
14 | 
15 | //sayfa isimli get değerim var mı diye kontrol ediyor eğer yoksa kendim bu değere index atıyorum.
16 | if (!isset($_GET['sayfa']))
17 | {
18 |     $_GET['sayfa']='index';
19 | }
20 | 
21 | switch ($_GET['sayfa'])
22 | {
23 |     //eğer burası index ise
24 |     case 'index':
25 |         require_once 'homepage.php';
26 |         break;
27 | 
28 |     //eğer case 'insert' ise
29 |     case 'insert':
30 |         //insert.php dahil edildi.
31 |         require_once 'insert.php';
32 |         break;
33 | 
34 |     //eğer case 'formInsert' ise
35 |     case 'formInsert':
36 |         //formInsert.php dahil edildi.
37 |         require_once 'formInsert.php';
38 |         break;
39 | 
40 |     //veri ayrıntı sayfası
41 |     case 'oku':
42 |         require_once 'oku.php';
43 |         break;
44 | 
45 |     //veri güncelleme
46 |     case 'formUpdate':
47 |         require_once 'formUpdate.php';
48 |         break;
49 | 
50 |     //veri sil
51 |     case 'sil':
52 |         require_once 'sil.php';
53 |         break;
54 | 
55 |     //kategoriler
56 |     case 'kategoriler':
57 |         require_once 'kategoriler.php';
58 |         break;
59 | 
60 |     //kategori ekle
61 |     case 'kategori_ekle':
62 |         require_once 'kategori_ekle.php';
63 |         break;
64 | 
65 |     //kategori
66 |     case 'kategori':
67 |         require_once 'kategori.php';
68 |         break;
69 | }
70 | 
71 | 
72 | ?>


--------------------------------------------------------------------------------
/PDO/insert.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | //burada veritabanına ekleme işlemi yapacağız.
 4 | //veriler diye bir tablo oluşturduğumuzu varsayalım.
 5 | 
 6 | /*                                                   veriler
 7 |  *  ==================================================================================================
 8 |  * id -> int (PK) , baslik -> varchar , icerik -> text , onay -> int , tarih-> timestamp (current_timestap())
 9 |  */
10 | 
11 | 
12 | /*
13 |  * Daha güvensiz hali:
14 |  * $db->query('INSERT INTO veriler SET baslik="açıklı başlık", icerik = "açıklı içerik", onay = 1');
15 |  *  dışarıdan müdahaleye açık.
16 |  */
17 | 
18 | //INSERT INTO tablo_adi SET kolon1=değer1
19 | //prepare ile sorgumuzu hazırlıyorum.
20 | $sorgu = $db->prepare('INSERT INTO veriler SET
21 | baslik = ?,
22 | icerik = ?,
23 | onay = ?');
24 | //sonrasında ekle isimli bir değişkende bu sorguları çalıştıracağım.
25 | $ekle = $sorgu->execute(['deneme başlık','deneme içerik',1]);
26 | 
27 | if ($ekle)
28 | {
29 |     echo "Verileriniz eklendi!";
30 | }else
31 | {
32 |     //eğer başarısız olursa errorInfo() çağrılacak bu bize bir dizi döndürecek ve print_r ile onu görebileceğiz.
33 |     print_r($sorgu->errorInfo());
34 |     //veya
35 |     $hata = $sorgu->errorInfo();
36 |     echo "<br>MySQL hatası: ".$hata[2];
37 | }
38 | 
39 | ?>


--------------------------------------------------------------------------------
/PDO/kategori.php:
--------------------------------------------------------------------------------
 1 |     <?php
 2 | 
 3 |     //eğer bir id değeri get edilmemişse index.php'ye yönlendirir.
 4 |     if (!isset($_GET['id']) || empty($_GET['id']))
 5 |     {
 6 |         header('Location:index.php?sayfa=kategoriler');
 7 |         exit;
 8 |     }
 9 | 
10 | 
11 |     $sorgu = $db->prepare('SELECT * FROM verikategorisi WHERE id = ? ');
12 |     $sorgu -> execute([
13 |         $_GET['id']
14 |     ]);
15 |     $kategori = $sorgu -> fetch(PDO::FETCH_ASSOC); //tek id değeri için veri çekeceğim için fetch
16 | 
17 |     if (!$kategori) //kategori yoksa
18 |     {
19 |         header('Location:index.php?sayfa=kategoriler');
20 |         exit;
21 |     }
22 |     {
23 |         $sorgu = $db->prepare('SELECT * FROM veriler 
24 |         WHERE kategori_id = ?
25 |         ORDER BY id DESC');
26 |         $sorgu -> execute([
27 |             $_GET['id']
28 |         ]);
29 |         $veriler = $sorgu-> fetchAll(PDO::FETCH_ASSOC);
30 | 
31 |     }
32 | 
33 |     ?>
34 | 
35 |     <?php if($veriler): //veriler varsa burayı göster ?>
36 |     <h3><?php echo $kategori['ad'];?> Kategorisi</h3>
37 |     <ul>
38 |         <?php foreach ($veriler as $vr): ?>
39 |         <li>
40 |             <!--İçeriklerin başlıkları listelendi-->
41 |             <?php echo $vr['baslik']; ?>
42 |             <div>
43 |                 <?php if($vr['onay'] == 1): ?>
44 |                     <!--Sadece onaylı olan içeriklerin başlıkları gösterilecek.-->
45 |                     <a href="index.php?sayfa=oku&id=<?php echo $vr['id'];?>">[OKU]</a>
46 |                 <?php endif; ?>
47 |                 <a href="index.php?sayfa=formUpdate&id=<?php echo $vr['id'] ?>">[DÜZENLE]</a>
48 |                 <a href="index.php?sayfa=sil&id=<?php echo $vr['id'] ?>">[SİL]</a>
49 |             </div>
50 |         </li>
51 |         <?php endforeach; ?>
52 |     <?php else: //yoksada burayı göster ?>
53 |             Bu kategoriye ait henüz veri eklenmemiştir.
54 |     <?php endif; ?>
55 | 


--------------------------------------------------------------------------------
/PDO/kategori_ekle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | if (isset($_POST['ad']))
 3 | {
 4 |     if (empty($_POST['ad']))
 5 |     {
 6 |         echo "Lütfen kategori adı belirtiniz!";
 7 |     }
 8 |     else
 9 |     {
10 |         //kategori ekle
11 |         $sorgu = $db -> prepare('INSERT INTO verikategorisi SET
12 |         ad = ?');
13 | 
14 |         $ekle = $sorgu -> execute([
15 |             $_POST['ad']
16 |         ]);
17 | 
18 |         //eğer ekleme başarılı ise
19 |         if ($ekle)
20 |         {
21 |             header('Location:index.php/?sayfa=kategoriler');
22 |         }
23 |         else //değilse
24 |         {
25 |             echo "Kategori eklenemedi!";
26 |         }
27 |     }
28 | 
29 | }
30 | 
31 | ?>
32 | 
33 | <form action="" method="post">
34 |     Kategori Adı: <br>
35 |     <input type="text" name="ad">
36 |     <button type="submit">Gönder</button>
37 | </form>


--------------------------------------------------------------------------------
/PDO/kategoriler.php:
--------------------------------------------------------------------------------
 1 | <a href="index.php?sayfa=kategori_ekle">[Kategori Ekle]</a>
 2 | <?php
 3 | 
 4 | //verikategorisi bilgilerini getirmek için.
 5 | $kategori = $db -> query('SELECT verikategorisi.* , COUNT(veriler.id) AS toplamVeri 
 6 | FROM verikategorisi
 7 | LEFT JOIN veriler ON veriler.kategori_id = verikategorisi.id
 8 | GROUP BY verikategorisi.id')->fetchAll(PDO::FETCH_ASSOC);
 9 | ?>
10 | 
11 | <ul>
12 |     <?php foreach ($kategori as $kt): ?>
13 |     <li>
14 |         <a href="index.php?sayfa=kategori&id=<?php echo $kt['id'];?>">
15 |             <?php echo $kt['ad']; ?>
16 |             (<?php echo $kt['toplamVeri']; ?>) <!--Yukarıda COUNT ifadesi sayesinde kategoriler
17 |             için mevcut olan toplam veri sayısı elde edilmiş oldu.-->
18 |         </a>
19 |     </li>
20 |     <?php endforeach; ?>
21 | </ul>
22 | 
23 | 
24 | 


--------------------------------------------------------------------------------
/PDO/oku.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | //eğer id yoksa veya boşsa
 3 | if (!isset($_GET['id']) || empty($_GET['id']))
 4 | {
 5 |     //index'e yönlendirme işlemi
 6 |     header('Location:index.php');
 7 |     exit;
 8 | }
 9 | 
10 | //veriler tablosundan id'si =
11 | $sorgu = $db->prepare('SELECT * FROM veriler WHERE id=?');
12 | $sorgu->execute([
13 |     //get edilen id'ye eşit olanı al
14 |     $_GET['id']
15 | ]);
16 | 
17 | //zaten tek bir veri alacağız (o id'ye ait olan).
18 | $veri = $sorgu->fetch(PDO::FETCH_ASSOC);
19 | 
20 | //eğer veri yoksa
21 | if (!$veri)
22 | {
23 |     //yine index'e yönlendir.
24 |     header('Location:index.php');
25 |     exit;
26 | }
27 | 
28 | ?>
29 | 
30 | <h3> <?php echo $veri['baslik']; ?></h3>
31 | <hr>
32 | <div>
33 |     <strong> Eklenme Tarihi: <?php echo $veri['tarih'] ?></strong>
34 |     <hr>
35 |     <?php echo nl2br($veri['icerik']) ?> <!-- Alt alta yazdırabilmek için-->
36 | </div>


--------------------------------------------------------------------------------
/PDO/sil.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | //eğer veri yoksa ya da boşsa
 4 | if (!isset($_GET['id']) || empty($_GET['id']))
 5 | {
 6 |     header('Location:index.php');
 7 |     exit;
 8 | }
 9 | 
10 | //DELETE FROM Tablo_Adi WHERE id = 2
11 | $sorgu = $db -> prepare('DELETE FROM veriler WHERE id = ?'); //veriler tablosunda id'si...
12 | 
13 | $sorgu -> execute([
14 |     $_GET['id'] //... şu olan veriyi sil
15 | ]);
16 | 
17 | //daha sonra index.php'ye yönlendir.
18 | header('Location:index.php');
19 | 
20 | 
21 | 
22 | 
23 | 
24 | 
25 | 
26 | ?>
27 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
   1 | # PHP
   2 | ## Başlıklar
   3 | 
   4 | 
   5 | * [PDO](https://github.com/yenilikci/php#pdo "PDO")
   6 |   * [Veritabanı Bağlantısı](https://github.com/yenilikci/php#veritaban%C4%B1-ba%C4%9Flant%C4%B1s%C4%B1-- "Veritabanı Bağlantısı")
   7 |   * [Veri Ekleme (INSERT)](https://github.com/yenilikci/php#veri-ekleme-insert- "Veri Ekleme (INSERT)")
   8 |   * [Veri Listeleme (SELECT](https://github.com/yenilikci/php#veri-listeleme-select- "Veri Listeleme (SELECT")) 
   9 |   * [Veri Güncelleme (UPDATE)](https://github.com/yenilikci/php#veri-g%C3%BCncelleme-update- "Veri Güncelleme (UPDATE)")
  10 |   * [Veri Silme (DELETE) ](https://github.com/yenilikci/php#veri-silme-delete- "Veri Silme (DELETE)")
  11 |   * [Birleştirici (JOIN) Kullanımı](https://github.com/yenilikci/php#birle%C5%9Ftirici-join-kullan%C4%B1m%C4%B1- "Birleştirici (JOIN) Kullanımı")
  12 |   * [Arama İşlemi (LIKE) Kulanımı](https://github.com/yenilikci/php#arama-i%CC%87%C5%9Flemi-like-kulan%C4%B1m%C4%B1- "Arama İşlemi (LIKE) Kulanımı") 
  13 | * [OOP](https://github.com/yenilikci/php#pdo "PDO")
  14 |   * [Sınıflar](https://github.com/yenilikci/php#s%C4%B1n%C4%B1flar- "Sınıflar")
  15 |   * [Görünürlük](https://github.com/yenilikci/php/blob/master/README.md#g%C3%B6r%C3%BCn%C3%BCrl%C3%BCk- "Görünürlük")
  16 |   * [Kurucu ve Yıkıcı Metot](https://github.com/yenilikci/php/blob/master/README.md#kurucu-ve-y%C4%B1k%C4%B1c%C4%B1-metot- "Kurucu ve Yıkıcı Metot")
  17 |   * [Kalıtım](https://github.com/yenilikci/php/blob/master/README.md#kal%C4%B1t%C4%B1m- "Kalıtım")
  18 |   * [Static Deyimi](https://github.com/yenilikci/php#static-deyimi- "Static Deyimi")
  19 |   * [Sınıf Sabitleri](https://github.com/yenilikci/php#s%C4%B1n%C4%B1f-sabitleri- "Sınıf Sabitleri")
  20 |   * [Sınıf Soyutlama](https://github.com/yenilikci/php#s%C4%B1n%C4%B1f-soyutlama- "Sınıf Soyutlama")
  21 |   * [Arayüzler](https://github.com/yenilikci/php#aray%C3%BCzler- "Arayüzler")
  22 |   * [İsim Uzayları](- "İsim Uzayları")
  23 | 
  24 | 
  25 | ## PDO
  26 | **Veritabanı adı:** *veri*
  27 | 
  28 | **Tablo adı:** *veriler*
  29 | | id | baslik  |icerik|onay|tarih|
  30 | | --- | --- | --- | --- | ---|
  31 | | 1  |  pdo1 | pdo ile veritabani1 | 1|2020-02-15 22:24:39
  32 | | 2  |  pdo2 | pdo ile veritabani2 | 1|2020-02-15 22:25:39
  33 | | 3  |  pdo3 | pdo ile veritabani3 | 1|2020-02-15 22:26:39
  34 | | 4  |  pdo4 | pdo ile veritabani4 | 1|2020-02-15 22:27:39
  35 | | 5  |  pdo5 | pdo ile veritabani5 | 1|2020-02-15 22:28:39
  36 | 
  37 | ### Veritabanı Bağlantısı  [🐘](https://github.com/yenilikci/php/blob/master/PDO/baglan.php "🐘")
  38 | ```php
  39 | <?php
  40 |     try
  41 |     {
  42 | 	//PDO Nesnesi. Parametreler: dsn,username,passwd
  43 |         $db = new PDO('mysql:host=localhost;dbname=veri','root',''); 
  44 |     }
  45 |     catch (PDOException $e)
  46 |     {
  47 |         //bağlantı başarısız olursa hatayı yakalayıp bilgi alıyoruz.
  48 |         $e -> getMessage();
  49 |     }
  50 | ?>
  51 | ```
  52 | ### Veri Ekleme (INSERT) [🐘](https://github.com/yenilikci/php/blob/master/PDO/formInsert.php "🐘")
  53 | ```sql
  54 | INSERT INTO Tablo_Adi SET kolon1 = değer1;
  55 | ```
  56 | ```php
  57 | //veriler tablosuna ekleme işlemi
  58 | $sorgu = $db -> prepare('INSERT INTO veriler SET
  59 |         baslik = ?,
  60 |         icerik = ?,
  61 |         onay = ?');
  62 | 
  63 | //baslik,icerik ve onayı işlem dizisine koyuyorum.
  64 | $ekle = $sorgu -> execute([
  65 |         $baslik,
  66 |         $icerik,
  67 |         $onay
  68 |         ]);
  69 | 
  70 | //eğer ekleme işlemi başarılıysa
  71 | if ($ekle)
  72 |         {
  73 |             //yönlendirme işlemi yapıyorum.
  74 |             header('Location:index.php');
  75 |         } 
  76 | else 
  77 |         {
  78 |             //değilse hata mesajını alıp ekrana basıyoruz.
  79 |             $hata = $sorgu -> errorInfo();
  80 |             echo "MySQL Hatası: ".$hata[2];
  81 |         }
  82 | ```
  83 | ### Veri Listeleme (SELECT) 🐘
  84 | ```sql
  85 | SELECT * FROM Tablo_Adi WHERE id = ?;
  86 | ```
  87 | ```php
  88 | //veriler tablosundan id'si =
  89 | $sorgu = $db -> prepare('SELECT * FROM veriler WHERE id=?');
  90 | $sorgu -> execute([
  91 |     //get edilen id'ye eşit olanı al
  92 |     $_GET['id']
  93 | ]);
  94 | 
  95 | //zaten tek bir veri alacağız o yüzden fetch() kullandım. (o id'ye ait olan)
  96 | $veri = $sorgu -> fetch(PDO::FETCH_ASSOC)
  97 | ```
  98 | ### Veri Güncelleme (UPDATE) [🐘](https://github.com/yenilikci/php/blob/master/PDO/formUpdate.php "🐘")
  99 | ```sql
 100 | UPDATE Tablo_Adi SET kolon1 = değer1 WHERE kolon=değer;
 101 | ```
 102 | ```php
 103 |   $sorgu = $db->prepare('UPDATE veriler SET
 104 |                 baslik = ?,
 105 |                 icerik = ?,
 106 |                 onay = ?
 107 |                 WHERE id = ?'); //id'si şu olan...
 108 | 
 109 | //sorgu değişkenimi execute ediyorum ve güncelle değişkenine atıyorum.
 110 |   $guncelle = $sorgu->execute([
 111 |                 $baslik, $icerik, $onay, $veri['id']
 112 |             ]);
 113 | 	    
 114 | //eğer güncelleme başarılıysa
 115 | if ($guncelle) 
 116 | {
 117 | 	header('Location:index.php?sayfa=oku&id=' . $veri['id']);
 118 | } 
 119 | else
 120 | {
 121 | 	echo "Güncelleme işlemi başarısız!";
 122 | }
 123 | ```
 124 | ### Veri Silme (DELETE) [🐘](https://github.com/yenilikci/php/blob/master/PDO/sil.php "🐘")
 125 | ```sql
 126 | DELETE FROM Tablo_Adi WHERE id = 2;
 127 | ```
 128 | ```php
 129 | $sorgu = $db -> prepare('DELETE FROM veriler WHERE id = ?'); //veriler tablosunda id'si...
 130 | 
 131 | $sorgu -> execute([
 132 |     $_GET['id'] //... şu olan veriyi sil
 133 | ]);
 134 | 
 135 | //daha sonra index.php'ye yönlendir.
 136 | header('Location:index.php');
 137 | ```
 138 | 
 139 | > Şimdi ise verilerimizi ilişkilendirebilmek için "**verikategorisi**" isimli bir tablo daha oluşturuyoruz.
 140 | 
 141 | **Veritabanı adı:** *veri* (aynı veritabanında çalışıyoruz)
 142 | 
 143 | **Tablo adı:** *verikategorisi*
 144 | 
 145 | | id | ad  |
 146 | | --- | --- |
 147 | | 1  |  php |
 148 | | 2  |  asp.net core | 
 149 | | 3  |  nodejs | 
 150 | | 4  |  django |
 151 | 
 152 | bununla birlikte **veriler** tablomuza verikategorisi tablosunun id'si ile eşleştireceğimiz **kategori_id** kolonunu ekliyoruz.
 153 | 
 154 | 
 155 | | id | baslik  |icerik |kategori_id|onay|tarih|
 156 | | --- | --- | --- | --- | ---|---|
 157 | | 1  |  pdo1 | pdo ile veritabani1 | 1|1|2020-02-15 22:24:39
 158 | | 2  |  pdo2 | pdo ile veritabani2 |1| 1|2020-02-15 22:25:39
 159 | | 3  |  pdo3 | pdo ile veritabani3 | 1|1|2020-02-15 22:26:39
 160 | | 4  |  pdo4 | pdo ile veritabani4 | 1|1|2020-02-15 22:27:39
 161 | | 5  |  pdo5 | pdo ile veritabani5 | 1|1|2020-02-15 22:28:39
 162 | 
 163 | ### Birleştirici (JOIN) Kullanımı [🐘](https://github.com/yenilikci/php/blob/master/PDO/homepage.php "🐘")
 164 | ```sql
 165 | INNER JOIN Tablo_Adi ON Tablo_Adi.id = digerTablo_Adi.id;
 166 | ```
 167 | Inner Join ile ortak değere sahip iki tablodaki ilişkili değerleri seçelim ve birleştirelim.
 168 | > Query içinde kullanımı:
 169 | 
 170 | ```sql
 171 | SELECT veriler.id , veriler.baslik , verikategorisi.ad AS kategori_adi , veriler.onay FROM veriler
 172 | INNER JOIN verikategorisi ON verikategorisi.id = veriler.kategori_id
 173 | ORDER BY veriler.id DESC;
 174 | ```
 175 | fetchAll() ile bu verileri çektiğimizi ve $veriler isimli bir değişkene atadığımızı varsayalım.
 176 | 
 177 | ```php
 178 | <?php if ($veriler): ?>
 179 |         <ul>
 180 |         <!-- foreach ile veriler çekiliyor $veriler as $vr-->
 181 |     <?php foreach ($veriler as $vr): ?>
 182 |         <li>
 183 |             <!--İçeriklerin başlıkları ve kategorileri listelendi-->
 184 |             <?php echo $vr['baslik']; ?>
 185 |             (<?php echo $vr['kategori_adi']; ?>)
 186 |             <div>
 187 |               <?php if($vr['onay'] == 1): ?>
 188 |                   <!--Sadece onaylı olan içeriklerin başlıkları gösterilecek.-->
 189 |                   <a href="index.php?sayfa=oku&id=<?php echo $vr['id'];?>">[OKU]</a>
 190 |               <?php endif; ?>
 191 |               <a href="index.php?sayfa=formUpdate&id=<?php echo $vr['id'] ?>">[DÜZENLE]</a>
 192 |               <a href="index.php?sayfa=sil&id=<?php echo $vr['id'] ?>">[SİL]</a>
 193 |           </div>
 194 |         </li>
 195 |     <?php endforeach;?>
 196 |         </ul>
 197 | <?php else: ?>
 198 |     <!--veri yoksa...-->
 199 |     <div>Henüz eklenmiş veri bulunmuyor!</div>
 200 | <?php endif; ?>
 201 | ```
 202 | #### Left Join
 203 | ```sql
 204 | SELECT * FROM Tablo_Adi LEFT JOIN digerTablo_Adi ON Tablo_adi.id = digerTablo_Adi.id;
 205 | ```
 206 | Sol tablodaki tüm satırları ve koşula uygun olan sağ tablodaki satırları seçip birleştirelim ve bunları gruplayalım.
 207 | > Query içinde kullanımı:
 208 | 
 209 | ```sql
 210 | SELECT verikategorisi.* , COUNT(veriler.id) AS toplamVeri 
 211 | FROM verikategorisi
 212 | LEFT JOIN veriler ON veriler.kategori_id = verikategorisi.id
 213 | GROUP BY verikategorisi.id
 214 | ```
 215 | fetchAll() ile bu verileri çektiğimizi ve $kategori isimli bir değişkene atadığımızı varsayalım.
 216 | 
 217 | ```php
 218 | <ul>
 219 |     <?php foreach ($kategori as $kt): ?>
 220 |     <li>
 221 |         <a href="index.php?sayfa=kategori&id=<?php echo $kt['id'];?>">
 222 |             <?php echo $kt['ad']; ?>
 223 |             (<?php echo $kt['toplamVeri']; ?>)
 224 |         </a>
 225 |     </li>
 226 |     <?php endforeach; ?>
 227 | </ul>
 228 | ```
 229 | ### Arama İşlemi (LIKE) Kulanımı [🐘](https://github.com/yenilikci/php/blob/master/PDO/homepage.php "🐘")
 230 | ```sql
 231 | SELECT * FROM Tablo_Adi WHERE Kolon_Adi LIKE "%a%";
 232 | ```
 233 | LIKE komutu WHERE komutu ile birlikte bir kolonda ilgili değeri aramak için kullanılır.
 234 | 
 235 | ####  Joker Karakterler:
 236 | ##### * Birden fazla bilinmeyen karakteri sorgulatacaksak kullanırız. 
 237 | ##### # Bilinmeyen tek rakam için kullanırız.
 238 | ##### ? Bilinmeyen tek karakter için kullanırız.
 239 | 
 240 | > Query içinde kullanımı:
 241 | 
 242 | ```php
 243 | <?php
 244 | 
 245 | $sql = ' SELECT veriler.id,veriler.baslik,verikategorisi.ad as kategori_adi,veriler.onay FROM veriler
 246 | INNER JOIN verikategorisi ON verikategorisi.id = veriler.kategori_id'; 
 247 | //sql sorgumu değişkene atadım
 248 | 
 249 | if (isset($_GET['arama'])) //eğer bir arama yapılmışsa
 250 | {
 251 |     //bu ifadeyi de sql ifademe dahil edeceğim:
 252 |     $sql .= ' WHERE veriler.baslik LIKE "%' . $_GET['arama'] . '%" || veriler.icerik LIKE "%' . $_GET['arama'] . '%" ';
 253 | }
 254 | $sql .= ' ORDER BY veriler.id DESC';
 255 | 
 256 | 
 257 | $veriler = $db->query($sql)->fetchAll(PDO::FETCH_ASSOC);
 258 | //son eklenen verilere göre listele
 259 | 
 260 | ?>
 261 | 
 262 | ```
 263 | ## OOP
 264 | ### Sınıflar [🐘](https://github.com/yenilikci/php/blob/master/OOP/sinif.php "🐘")
 265 | Bir sınfı tanımlamak için class anahtar kelimesi kullanılır ve ardından sınıfın özel ismi yazılır.
 266 | Sınıflar isimlendirilirken barındıracağı özellikler neticesinde ve yerine getireceği işlevler düşünülerek isimlendirme yapılması mantıklı olandır.
 267 | İsimlendirme yapılırken türkçe karakter kullanımına izin vermektedir.
 268 | Harf veya alt çizgi ile sınıf ismini başlatabiliriz.
 269 | 
 270 | **Örnek Sınıf Kullanımı:**
 271 | ```php
 272 | <?php
 273 | class Uye
 274 | { 
 275 |     public $ad = 'Melih'; //özellik tanımlamaları
 276 |     public $soyad = 'Celik';
 277 |     const DOGUMTARIHI = 1999; //sabit tanımı
 278 |     
 279 |     //başına public koyulmaz ise varsayılan olarak public atanır
 280 |     function stringAdDondur()
 281 |     {
 282 |         return 'Melih';
 283 |     }
 284 | 
 285 |     public function stringSoyadDondur()
 286 |     {
 287 |         return 'Celik';
 288 |     }
 289 | 
 290 |     //geriye değer döndüren parametreli fonksiyon
 291 |     public function kacYasinda($gunumuz,$dogumTarihi)
 292 |     {   
 293 |         return $gunumuz - $dogumTarihi;
 294 |     }
 295 | 
 296 |     //özellikleri kullanarak fonksiyon içerisinde değer geri döndürmek için $this kullanılır ve this ile yerel özelliklere erişim sağlanır.
 297 |     function adDondur()
 298 |     {
 299 |         return $this->ad;
 300 |     }
 301 |     function soyadDondur()
 302 |     {
 303 |         return $this->soyad;
 304 |     }
 305 | 
 306 |     //fonksiyon içerisinde fonksiyonumuzu döndürmek isteseydik
 307 |     function yasBas()
 308 |     {
 309 |         return $this->kacYasinda(2020,$this::DOGUMTARIHI);
 310 |     }
 311 |     
 312 |     //sabiti geriye döndürmek
 313 |     function dogumTarihi()
 314 |     {
 315 |         return $this::DOGUMTARIHI;
 316 |     }//veya self kullanabiliriz
 317 |     function dogumTarihi2()
 318 |     {
 319 |         return self::DOGUMTARIHI;
 320 |     }
 321 | }
 322 | ?>
 323 | ```
 324 | **Şimdi bu sınıftan nesneler türetelim**
 325 | ```php
 326 | <?php
 327 | //sınıftan nesne olusturma
 328 | $uye = new Uye();
 329 | //veya 
 330 | $uye2 = new Uye;
 331 | ?>
 332 | ```
 333 | **nesnelerimiz ile bu sınıfın özellik ve metotlarına erişelim:**
 334 | 
 335 | > Sınıf içerisindeki özelliklere ve metotlara erişmek için -> işareti kullanılır
 336 | 
 337 | Metotlara erişmek ve ekrana yazdırmak
 338 | ```php
 339 | echo $uye->stringAdDondur() . "<br>";
 340 | ```
 341 | Özelliğe erişmek ve ekrana yazdırmak
 342 | ```php
 343 | echo $uye->soyad . "<br>" ;
 344 | ```
 345 | Sabite erişmek ve ekrana yazdırmak
 346 | ```php
 347 | echo $uye::DOGUMTARIHI;
 348 | ```
 349 | uye2 için özelliklere farklı değerler atayalım
 350 | ```php
 351 | $uye2->ad = 'Farklıİsim';
 352 | $uye2->soyad = 'FarkliSoyad';
 353 | ```
 354 | 
 355 | uye2'nin değerlerini ekrana yazalım
 356 | ```php
 357 | <?php
 358 | echo "<hr>";
 359 | echo "<br>". $uye2->ad;
 360 | echo "<br>". $uye2->soyad;
 361 | echo "<br>". $uye2::DOGUMTARIHI;
 362 | ?>
 363 | ```
 364 | Parametreli metodu çağırmak
 365 | ```php
 366 | <?php
 367 | echo "<hr>";
 368 | echo "KAÇ YAŞINDALAR?" . "<br>";
 369 | echo $uye->kacYasinda(2020,$uye::DOGUMTARIHI);
 370 | ?>
 371 | ```
 372 | Özellik ve fonksiyonları geri döndüren fonskiyonları çağırmak 
 373 | ```php
 374 | <?php
 375 | echo "<hr>";
 376 | echo "Birde özellikleri geri döndürerek ad ve soyadı ekrana bastıralım" . <br>";
 377 | echo $uye->adDondur() . "<br>";
 378 | echo $uye->soyadDondur()."<br>";
 379 | echo "<br>". "Birde metodu geri döndürerek yaşı ekrana bastıralım" . "<br>";
 380 | echo $uye->yasBas()."<br>";
 381 | ?>
 382 | ```
 383 | > this nesneyi referans alır,self ise sınıfı referans alır
 384 | 
 385 | This ve self ile sabit döndüren fonksiyonların ekrana bastırılması
 386 | ```php
 387 | <?php
 388 | echo $uye->dogumTarihi()."<br>"; //this kullanıldı
 389 | echo $uye->dogumTarihi2(); //self kullanıldı
 390 | ?>
 391 | ```
 392 | Çıktı
 393 | 
 394 | ![php-sınıf-çıktı](https://user-images.githubusercontent.com/57464067/81638248-33ac8f80-9421-11ea-9578-f81f5bb55961.png)
 395 | 
 396 | ### Görünürlük [🐘](https://github.com/yenilikci/php/blob/master/OOP/gorunurluk.php "🐘")
 397 | Bir özellik, sabit ya da metodun görünürlüğünü üç farklı şekilde belirleyebiliriz.
 398 | Kullanımlara örnek sınıf üzerinden bakacak olursak:
 399 | ```php
 400 | <?php
 401 | class Test
 402 | {
 403 |     public $a = 'a'; //her yerden erişilebilir.
 404 | 
 405 |     private $b = 'b'; //sadece sınıf içerisinden erişilebilir
 406 | 
 407 |     public function geriDonB()
 408 |     {
 409 |         return $this->b; //private özelliği public metotta geriye döndürebilirim
 410 |     }
 411 | 
 412 |     protected $c = 'c';
 413 |     //korumalı, aynı private gibi dışarıdan erişilemez sınıf içinde erişilebilir, miras aldığımız sınıfta da kullanabiliriz
 414 | 
 415 |     private function geriDonA() //private func
 416 |     {
 417 |         return $this->a;
 418 |     }
 419 | 
 420 |     protected function geriDonC() //protected func
 421 |     {
 422 |         return $this->c;
 423 |     }
 424 | }
 425 | ?>
 426 | ```
 427 | 
 428 | Şimdi bu özellik ve metotları ekrana bastırmaya çalışalım
 429 | ```php
 430 | <?php
 431 | $test = new Test;
 432 | 
 433 | echo $test->a; //bu özelliğe rahatça ekrana basabildim
 434 | 
 435 | echo $test->b; //bu özelliği ekrana bastırmak istediğimde hata ile karşılaşıyorum
 436 | 
 437 | echo $test->geriDonB(); //private özelliği public fonksiyon ile bastırdım
 438 | 
 439 | echo $test->c; //hata
 440 | 
 441 | echo $test->geriDonA(); //hata
 442 | 
 443 | echo $test->geriDonC(); //hata
 444 | ?>
 445 | ```
 446 | ### Kurucu ve Yıkıcı Metot [🐘](https://github.com/yenilikci/php/blob/master/OOP/kurucuyikici.php "🐘")
 447 | 
 448 | Kurucu metot bir sınıf başlatıldığında otomatik olarak çağrılacak fonksiyondur.
 449 | ```php
 450 | <?php
 451 |     public function __construct($a)
 452 |     {
 453 | 			.		.		.
 454 |     }
 455 | ?>
 456 | ```
 457 | 
 458 | Yıkıcı metot bir sınıfın çalışması bittiğinde çalışacak son metot.
 459 | ```php
 460 | <?php
 461 |     public function __destruct()
 462 |     {
 463 | 			.		.		.
 464 |     }
 465 | ?>
 466 | ```
 467 | 
 468 | Örneğin;
 469 | ```php
 470 | <?php
 471 | 
 472 | class YapYik
 473 | {
 474 |     private $degisken;
 475 | 
 476 |     //parametreli kurucu metot
 477 |     public function __construct($a)
 478 |     {
 479 |         $this->degisken = $a;
 480 |         echo $this->degisken.PHP_EOL;
 481 |     }
 482 | 
 483 |     public function bas()
 484 |     {
 485 |         echo 'ekrana yazı bastım'.PHP_EOL;
 486 |     }
 487 | 
 488 |     //yıkıcı metot
 489 |     public function __destruct()
 490 |     {
 491 |         echo 'yıkıcı metot çalıştı'.PHP_EOL;
 492 |     }
 493 | 
 494 | }
 495 |  
 496 | $nesne = new YapYik('Kurucu metot çalıştı');
 497 | $nesne->bas();
 498 | 
 499 | ?>
 500 | ```
 501 | Çıktı
 502 | 
 503 | ![çıktı](https://user-images.githubusercontent.com/57464067/81704814-f377fc00-9476-11ea-9aed-2387e4953b53.png)
 504 | 
 505 | ### Kalıtım [🐘](https://github.com/yenilikci/php/blob/master/OOP/kalitim.php "🐘")
 506 | 
 507 | Kalıtım sınıf ve nesne ilişkilerini düzenleyen iyi kurgulanmış bir prensiptir.
 508 | Türeyen sınıflar ,türetilen sınıfların özellik ve metotlarını public ve protected olduğu sürece kullanabilirler.
 509 | Genişletmek için extends deyimi kullanılır.
 510 | 
 511 | Örnek bir temel(base) - ebeveyn(parent) sınıf :
 512 | ```php
 513 | <?php
 514 | class Calisan
 515 | {
 516 |     public $maas;
 517 |     public $adsoyad;
 518 | 
 519 |     public function setAdSoyad($adsoyad)
 520 |     {
 521 |         //sınıfın içerisindeki adsoyad dışarıdan gelen adsoyad değerine eşit olsun
 522 |         $this->adsoyad = $adsoyad;
 523 |     }
 524 | 
 525 |     public function maas($maas)
 526 |     {
 527 |         //sınıfın içerisinde maas dışarıdan gelen maas değerine eşit olsun
 528 |         $this->maas = $maas;
 529 |     }
 530 | 
 531 |     public function senelikMaas()
 532 |     {
 533 |         return ($this->maas*12).'₺';
 534 |     }
 535 | }
 536 | ?>
 537 | ```
 538 | 
 539 | Calisan sınıfından türetilen Muhasebe sınıfı:
 540 | ```php
 541 | <?php
 542 | class Muhasebe extends Calisan{}
 543 | ?>
 544 | ```
 545 | Calisan sınıfından türetilen IT sınıfı:
 546 | > Temel sınıfta bulunan bir fonksiyonu türeyen sınıfta tekrar tanımlayıp ama temel sınıftaki fonksiyonu kullanmak istersem parent deyimini kullanırım
 547 | ```php
 548 | <?php
 549 | class IT extends Calisan{
 550 |     public function senelikMaas()
 551 |     {
 552 |         return 'IT Çalışanı: '.$this->adsoyad.' senelik maaş olarak '.parent::senelikMaas();
 553 |     }
 554 | }
 555 | ?>
 556 | ```
 557 | 
 558 | Zincirleme olarak kalıtım almak ve en aşağıdaki sınıftan en temel sınıfın özellik ve metotlarına erişmek:
 559 | ```php
 560 | <?php
 561 | class x
 562 | {
 563 |     public function bas()
 564 |     {
 565 |         return 'x:bas';
 566 |     }
 567 | }
 568 | class y extends x
 569 | {
 570 |     public function bas()
 571 |     {
 572 |         return 'y:bas';
 573 |     }
 574 | }
 575 | class z extends y
 576 | {
 577 |     public function bas()
 578 |     {
 579 |         return 'z:bas';
 580 |     }
 581 |     public function basGetir()
 582 |     {
 583 |         return [
 584 |             'z' => self::bas(),
 585 |             'y' => parent::bas(),
 586 |             'x' => x::bas()
 587 |         ];
 588 |     }
 589 | }
 590 | 
 591 | $z = new z;
 592 | print_r($z->basGetir());
 593 | ?>
 594 | ```
 595 | ### Static Deyimi [🐘](https://github.com/yenilikci/php/blob/master/OOP/staticornek.php "🐘")
 596 | 
 597 | Static tanımlama ile sınıf örneği oluşturmadan o sınıfın static metot ve özelliklerine erişilebilir.
 598 | Bu erişimi sağlamak için çift iki nokta erişecini kullanırız. (::)
 599 | Fakat php şu anda sınıfların static "METOTLARINA" sınıf örneği oluşturarakta erişime izin vermektedir.
 600 | Static metotlar ilk çağrıldığında ram'e aktarılır ve daha sonra ramden okunur, performans açısından kuvvetlidir.
 601 | 
 602 | ```php
 603 | <?php
 604 | 
 605 | class Test
 606 | {
 607 |     public static function selam()
 608 |     {
 609 |         return 'selam';
 610 |     }
 611 | }
 612 | 
 613 | //içerisinde static metot olan bir sınıfımız varsa 
 614 | echo Test::selam(); //new ile oluşturmadan bu şekilde metotu çağırabilirim
 615 | 
 616 | ?>
 617 | ```
 618 | Static metotlar içerisinde yalnızca sınıfın static özelliklerine erişim sağlanabilir.
 619 | 
 620 | ```php
 621 | <?php
 622 | 
 623 | class Test
 624 | {
 625 |     public static $b = 'test2';
 626 | 
 627 |     public static function test()
 628 |     {
 629 | 
 630 |         return self::$b;
 631 |     }
 632 | }
 633 | 
 634 | ?>
 635 | ```
 636 | Dosya yazma, okuma işlemlerini gerçekleştiren static metotlar yazalım ve bunlara hem sınıf örneği başlatarak hemde sınıf örneği kullanmadan erişelim:
 637 | 
 638 | ```php
 639 | <?php
 640 | 
 641 | class File
 642 | {
 643 |     public static $dosyaAdi;
 644 |     public static function Olustur($dosyaAdi,$icerik)
 645 |     {
 646 |         self::$dosyaAdi = $dosyaAdi;
 647 |         $dosya = fopen($dosyaAdi,'w+');
 648 |         fwrite($dosya,$icerik);
 649 |         fclose($dosya);
 650 |     }
 651 |     public static function Oku($dosyaAdi = null)
 652 |     {   
 653 |         if(!$dosyaAdi) $dosyaAdi = self::$dosyaAdi; 
 654 |         return file_get_contents($dosyaAdi);
 655 |     }
 656 | }
 657 | //sınıfın örneğini oluşturmadan
 658 | File::Olustur('a.txt','deneme içeriği');
 659 | 
 660 | //sınıf örneklenerek
 661 | $ds = new File;
 662 | echo $ds->Oku();
 663 | 
 664 | ?>
 665 | ```
 666 | ### Sınıf Sabitleri [🐘](https://github.com/yenilikci/php/blob/master/OOP/sabit.php "🐘")
 667 | 
 668 | Sınıf sabitleri tanımlanırken **const** ifadesi kullanılır. Değişkenler gibi tanımlanırken $ imi kullanılmaz. 
 669 | Sabitlerin değeri bir değişken,bir sınıfa ait özellik veya bir işlem olmamalıdır. Sınıf sabitleri "HER SINIF İÇİN BİR KERE AYRILIR", her sınıf örneği için ayrılmaz.
 670 | 
 671 | Örneğin File isminde bir sınıfımız olsun ve DIRECTORY isimli bir sabit içersin:
 672 | ```php
 673 | <?php
 674 | class File
 675 | {
 676 | 
 677 |     const DIRECTORY = __DIR__; // __DIR__ hangi dizinde ise bize onun ismini döndürür
 678 |     public function getDirectory()
 679 |     {
 680 |         return self::DIRECTORY; //dizin yolunu geri döndürür, self(sınıfı referans alır) ile eriştim
 681 |     }
 682 | 
 683 | }
 684 | ?>
 685 | ```
 686 | Geri dönen değeri ekranda görmek:
 687 | ```php
 688 | <?php
 689 | $file = new File;
 690 | echo $file->getDirectory();
 691 | 
 692 | //veya sınıfı başlatmadan da sabitin değerini alabiliriz
 693 | 
 694 | echo "<br>". File::DIRECTORY;
 695 | ?>
 696 | ```
 697 | Şimdi de Folder isimli bir sınıf tanımlayalım ve bu da File sınıfından türetilsin:
 698 | ```php
 699 | <?php
 700 | class Folder extends File
 701 | {
 702 |     public function getDirectory()
 703 |     {
 704 |         return parent::DIRECTORY; //File sınıfındaki DIRECTORY sabitini kullandım, parent(temel sınıfı)'ı baz aldım.
 705 |     }
 706 | }
 707 | ?>
 708 | ```
 709 | Dizin değerini geri döndürme işlemini Folder sınıfının nesnesi ile yapalım:
 710 | ```php
 711 | <?php
 712 | $folder = new Folder;
 713 | echo "<br>". $folder->getDirectory();
 714 | ?>
 715 | ```
 716 | Çıktımız şu şekilde olacaktır:
 717 | 
 718 | ![const-ifadesi](https://user-images.githubusercontent.com/57464067/81931351-9f922200-95f2-11ea-88fa-a8cecf8906b8.png)
 719 | 
 720 | ### Sınıf Soyutlama [🐘](https://github.com/yenilikci/php/blob/master/OOP/soyutlama.php "🐘")
 721 | 
 722 | Sınıfın başına **abstract** deyimi getirilerek bu sağlanır. Soyut sınıflarda soyut metotların (soyut metotlar tanımlanırken yine abstract deyimini kullanırız) yanında soyut olmayan metotlar da kullanılabilmektedir.
 723 | Bu özelliği ile arayüzlerden ayrılır ve esneklik kazanır. Tanımladığımız başka bir sınıfı extends deyimi ile tanımlanan herhangi bir soyut sınıftan türetebiliriz. Türetilen bu sınıfta soyut sınıfta tanımlanan soyut metotlar bulunmak zorundadır.
 724 | Soyut sınıflar başlatılamazlar, soyut sınıftan türettiğim normal sınıflarım ise başlatılabilirler. Soyut sınıfların soyut metotlarında sadece fonksiyon başlığı yazılır, fonksiyon gövdesi yazılmaz.
 725 | 
 726 | Örneğin PHP tabanlı bir CMS'e eklenti geliştirdiğimiz senaryoyu ele alalım bu basit ama anlaşılır bir örnek olacak.
 727 | Eklenti isimli bir soyut sınıf tasarlayalım:
 728 | 
 729 | ```php
 730 | <?php
 731 | abstract class Eklenti //soyut sınıf
 732 | {
 733 |     abstract public function setTitle($title); //soyut metot, gövdesi yazılmaz, zorunluluk bildirir
 734 |     abstract public function setContent($content); //soyut metot, gövdesi yazılmaz, zorunluluk bildirir
 735 |     //normal metot 
 736 |     public function show()
 737 |     {
 738 |         echo '<h1>'.$this->title.'</h1>';
 739 |         echo '<p>'.$this->content.'</p>';
 740 |     }
 741 | }
 742 | ?>
 743 | ```
 744 | Sınıfın title ve content özelliklerini az sonra anlamlandıracağız, şimdi ise Eklenti isimli soyut sınıftan türeyen iki adet sınıf tanımlayalım.
 745 | 
 746 | SonYorumlar sınıfı:
 747 | ```php
 748 | <?php
 749 | class SonYorumlar extends Eklenti //soyut sınıftan türedi
 750 | {
 751 |     public function setTitle($title)
 752 |     {
 753 |         //özelliğin tanımı metot içinde yapıldı (title)
 754 |         $this->title = $title;
 755 |     }
 756 |     public function setContent($content)
 757 |     {
 758 |         //özelliğin tanımı metot içinde yapıldı (content)
 759 |         $this->content = $content;
 760 |     }
 761 | }
 762 | ?>
 763 | ```
 764 | SosyalMedya sınıfı:
 765 | ```php
 766 | <?php
 767 | class SosyalMedya extends Eklenti //soyut sınıftan türedi
 768 | {
 769 |     public function setTitle($title)
 770 |     {
 771 |         //özelliğin tanımı metot içinde yapıldı (title)
 772 |         $this->title = $title;
 773 |     }
 774 |     public function setContent($content)
 775 |     {
 776 |         //özelliğin tanımı metot içinde yapıldı (content)
 777 |         $this->content = $content;
 778 |     }
 779 | }
 780 | ?>
 781 | ```
 782 | 
 783 | Daha sonrasında bu iki sınıfımı başlatıyorum, title ve content özelliklerini set ediyorum:
 784 | ```php
 785 | <?php
 786 | //SonYorumlar sınıfını başlatıyorum
 787 | $sonyorumlar = new SonYorumlar;
 788 | //değerleri set edelim
 789 | $sonyorumlar->setTitle('Son Yorumlar');
 790 | $sonyorumlar->setContent('Son Yorumlar Burada Gözükecek');
 791 | 
 792 | //SosyalMedya sınıfını başlatıyorum
 793 | $sosyalmedya = new SosyalMedya;
 794 | //değerleri set edelim
 795 | $sosyalmedya->setTitle('Sosyal Medya');
 796 | $sosyalmedya->setContent('Sosyal Medya Bağlantıları Burada Gözükecek');
 797 | ?>
 798 | ```
 799 | Şimdi ise soyut sınıfımda tanımladığım ama soyut olmayan show() metodum ile set edilen özellikleri her bir nesnem için çağırıyorum:
 800 | ```php
 801 | <?php
 802 | echo $sonyorumlar->show();
 803 | echo "<br>";
 804 | echo $sosyalmedya->show();
 805 | ?>
 806 | ```
 807 | Çıktı şu şekilde olacaktır:
 808 | 
 809 | ![title-content](https://user-images.githubusercontent.com/57464067/81936930-9194cf00-95fb-11ea-87ac-a28366bfefa3.png)
 810 | 
 811 | ### Arayüzler [🐘](https://github.com/yenilikci/php/blob/master/OOP/arayuz.php "🐘")
 812 | 
 813 | Arayüz tanımlamak için **interface** deyimini kullanırız. Arayüzler soyut sınıflara benzer fakat bazı temel farklılıkları vardır.
 814 | Öncelikli farkı **arayüz**lerin tüm erişim belirleyicileri **public** olmak zorundadır, **soyut sınıf**larda bu **public, protected veya private** olabilir. <br>
 815 | **Arayüzler** soyut metotlar ve sabitler içerir, **soyut sınıflar** soyut metotlar,sabitler,normal metotlar ve özellikler içerir. <br>
 816 | **PHP** dilinde **arayüzlerin** diğer dillerden bir farklılığı vardır, **static metotları da içerebilir**. <br>
 817 | Arayüzler nesne olarak başlatılamazlar (new anahtar kelimesi ile). <br>
 818 | Arayüzlerin içerisinde **kurucu** ve **yıkıcı** metotlar **tanımlanabilir**. <br>
 819 | Arayüzler kendi içerisinde **extends** deyimi ile genişleyebilir Hatta birden fazla arayüz kalıtılabilir **PHP** de sıfılar arasında çoklu kalıtım desteklenmese de arayüzler arasında bu mümkündür. <br>
 820 | Aynı sınıfta birden fazla **arayüz** kullanılabilir, fakat aynı sınıf sadece bir **abstract** sınıftan türeyebilir.
 821 | 
 822 | Örneğin Islem adında bir arayüz tanımlayalım:
 823 | ```php
 824 | <?php
 825 | interface Islem
 826 | {
 827 |     public function Olustur($tabloAdi,$id);
 828 |     public function Oku($tabloAdi,$id);
 829 |     public function Guncelle($tabloAdi,$veri,$id);
 830 |     public function Sil($tabloAdi,$id);
 831 | }
 832 | ?>
 833 | ```
 834 | 
 835 | Bundan farklı olarak birde VT adında bir arayüz tanımlayalım:
 836 | ```php
 837 | <?php
 838 | interface VT 
 839 | {
 840 |     public function baglan($host,$dbname,$kadi,$sifre);
 841 | }
 842 | ?>
 843 | ```
 844 | Şimdi ise Veritabani sınıfımıza bu arayüzleri implement edelim:
 845 | ```php
 846 | <?php
 847 | class VeriTabani implements Islem,VT
 848 | {
 849 |     public function baglan($host,$dbname,$kadi,$sifre)
 850 |     {
 851 | 
 852 |     }
 853 | 
 854 |     public function Olustur($tabloAdi,$id)
 855 |     {
 856 | 
 857 |     }
 858 |     public function Oku($tabloAdi,$id)
 859 |     {
 860 | 
 861 |     }
 862 |     public function Guncelle($tabloAdi,$veri,$id)
 863 |     {
 864 |         
 865 |     }
 866 |     public function Sil($tabloAdi,$id)
 867 |     {
 868 | 
 869 |     }
 870 | }
 871 | ?>
 872 | ```
 873 | Görüldüğü üzere arayüzlerde tanımlanan fonksiyonların hepsi implemente edilen VeriTabani sınıfında kullanıldı, eğer bu fonksiyonları VeriTabani sınıfında yazmasaydık hata alırdık. Fonksiyonların başında herhangi bir abstract deyimi yer almasada arayüzlerde tanımlanan fonksiyonlar soyut fonksiyon olarak tanımlandı.
 874 | 
 875 | PHP de çoklu arayüz kullanımı ve multi-inheritance istisnası:
 876 | ```php
 877 | <?php
 878 | interface x
 879 | {
 880 |     public function basX();
 881 | }
 882 | 
 883 | interface y
 884 | {
 885 |     public function basY();
 886 | }
 887 | 
 888 | interface z extends x,y
 889 | {
 890 |     public function basZ();
 891 | }
 892 | 
 893 | class Test implements z
 894 | {
 895 |     public function basX()
 896 |     {
 897 |         
 898 |     }
 899 |     public function basY()
 900 |     {
 901 |         
 902 |     }
 903 |     public function basZ()
 904 |     {
 905 | 
 906 |     }
 907 | }
 908 | ?>
 909 | ```
 910 | ### İsim Uzayları [🐘](https://github.com/yenilikci/php/tree/master/OOP/namespace/uygulama "🐘")
 911 | 
 912 | Birden çok geliştiricisi olan bir projenin kütüphaneleri yazılırken aynı isimli sınıflar oluşturulmuş olabilir. Biz bu sınıfları kullanmak istediğimizde uygulamamız hangi kütüphanedeki sınıfı çağırması gerektiğini bilemez ve fatal error benzeri sorunlar ile karşılaşırız.Bu ve bunun gibi hataların önüne geçmek için isim uzaylarını kullanmamız gerekmektedir.
 913 | Aynı isimli iki sınıfı farklı isim uzayları altında tanımlar ve bu isime göre sınıfımızı çağırırsak karışıklık ortadan kalkar ve modülerlik artar.
 914 | 
 915 | İsim uzayı tanımlayabilmek için **namespace** deyimini kullanmamız gerekmektedir.Örneğin iki tane sınıf yazalım ve bu iki sınıfımızın ismi de Bildirimler olsun. Bir tanesi Uygulama klasörünün altındaki Helper klasörü altında diğeri ise Uygulama klasörünün altındaki Controller klasöründe yazılmış olsun.
 916 | 
 917 | İsim uzayları tanımlanırken okunabilirliği artırmak için içinde bulunduğu klasör dizin yapısına göre isimlendirilmesi büyük kolaylık sağlayacaktır. Örneğin;
 918 | 
 919 | ```php
 920 | <?php
 921 | namespace Uygulama\Helper;
 922 | ?>
 923 | ```
 924 | ve
 925 | 
 926 | ```php
 927 | <?php
 928 | namespace Uygulama\Controller;
 929 | ?>
 930 | ```
 931 | gibi tanımlamalar yapabiliriz. Burada aslında bir klasör eşleşmesi yoktur, sınıfları gerçeklerken kolaylık olsun ve anlaşılır olsun diye isim uzaylarımızı böyle isimlendirdik.
 932 | 
 933 | ve şimdi bu isim uzayları içerisinde sınıflarımızı tanımlayalım iki sınıfımızın ismi de Bildirimler olsun.
 934 | 
 935 | #### uygulama->controller altındaki Bildirimler sınıfı:
 936 | ```php
 937 | <?php
 938 | namespace Uygulama\Controller;
 939 | 
 940 | class Bildirimler
 941 | {
 942 |     public function __construct()
 943 |     {
 944 |         echo 'Controller İçin Bildirimler oluşturuldu!';
 945 |     }
 946 | }
 947 | ?>
 948 | ```
 949 | 
 950 | #### uygulama->helper altındaki Bildirimler sınıfı:
 951 | 
 952 | ```php
 953 | <?php
 954 | namespace Uygulama\Helper;
 955 | 
 956 | class Bildirimler
 957 | {
 958 |     public function __construct()
 959 |     {
 960 |         echo 'Helper İçin Bildirimler oluşturuldu!';
 961 |     }
 962 | }
 963 | ?>
 964 | ```
 965 | 
 966 | Uygulama içerisindeki index.php içerisinde bu iki sınıfı gerçekleyelim bunu **use** deyimini kullanarak yapabiliriz.
 967 | 
 968 | ```php
 969 | <?php
 970 | // use deyimini kullanarakta yapabilirim
 971 | use Uygulama\Controller\Bildirimler; // use namespaceismi\sınıfismi;
 972 | $controllerBildirim = new Bildirimler
 973 | ?>
 974 | ```
 975 | veya use deyimini **kullanmayarak**, direk nesne oluştururken isim uzayını sınıf isminin başına ekleyerekte bunu sağlayabilirim.
 976 | ```php
 977 | <?php
 978 | //veya şöyle bir kullanımda yapabilirim
 979 | $helperBildirim = new Uygulama\Helper\Bildirimler;
 980 | ?>
 981 | ```
 982 | #### index.php dosyasının son hali :
 983 | 
 984 | ```php
 985 | <?php
 986 | require __DIR__.'/controller/bildirimler.php';
 987 | require __DIR__.'/helper/bildirimler.php';
 988 | 
 989 | // use deyimini kullanarakta yapabilirim
 990 | use Uygulama\Controller\Bildirimler; // use namespaceismi\sınıfismi;
 991 | $controllerBildirim = new Bildirimler;
 992 | 
 993 | echo '<br>';
 994 | 
 995 | //veya şöyle bir kullanımda yapabilirim
 996 | $helperBildirim = new Uygulama\Helper\Bildirimler;
 997 | 
 998 | ?>
 999 | ```
1000 | çıktımız ise şu şekilde olacaktır:
1001 | 
1002 | ![controller-helper](https://user-images.githubusercontent.com/57464067/82132175-94ebae80-97e5-11ea-9347-f8b11f16ffaf.png)
1003 | 
1004 | 
1005 | 
1006 | 
1007 | 
1008 | 
1009 | 


--------------------------------------------------------------------------------