PHP'nin 30 yıllık evrimini derinlemesine inceleyelim.

1. Başlangıç Dönemi (1994-1997)

PHP/FI (Personal Home Page / Forms Interpreter) - 1994

Rasmus Lerdorf tarafından kendi kişisel web sitesini yönetmek için C dilinde yazılan basit CGI scriptleri olarak başladı. İlk versiyonda:

• Basit değişken sistemi
• Form işleme yetenekleri
• Ziyaretçi sayacı gibi temel araçlar

PHP/FI 2.0 - 1995-1996

• SQL desteği eklendi (mSQL)
• Gerçek bir programlama dili haline gelmeye başladı
• Ancak hala çok sınırlı ve kişisel kullanıma yönelikti

2. Modern PHP'nin Temeli (1997-2000)

PHP 3.0 - Haziran 1997

Zeev Suraski ve Andi Gutmans, PHP'yi tamamen yeniden yazdılar. Bu versiyon PHP'yi ciddi bir web programlama diline dönüştürdü.

Önemli Yenilikler:

• Nesne yönelimli programlama desteği (çok basit düzeyde)
• Modüler genişletilebilir mimari
• Çok sayıda veritabanı desteği (MySQL, PostgreSQL, Oracle)
• ODBC desteği
• Üçüncü parti API'leri için destek
• Daha tutarlı sözdizimi

Özellikler:

// PHP 3'te basit class kullanımı
class User {
    var $name;
    var $email;
    
    function setName($name) {
        $this->name = $name;
    }
}

PHP 4.0 - 22 Mayıs 2000

Zend Engine 1.0 ile geldi. Bu, PHP'nin performansını önemli ölçüde artırdı.

Gelen Özellikler:

• Zend Engine: PHP'nin çekirdeği tamamen yeniden yazıldı
• Session yönetimi (built-in)
• Output buffering (ob_start, ob_get_contents)
• Gelişmiş array fonksiyonları
• Referanslar ve referans sayma sistemi
• HTTP_GET_VARS, HTTP_POST_VARS gibi süper global'ler (henüz $_GET yoktu)
• COM/DCOM desteği (Windows için)
• Java ile entegrasyon
• Perl Compatible Regular Expressions (PCRE)

// Session kullanımı
session_start();
$_SESSION['user_id'] = 123;

// Output buffering
ob_start();
echo "Bu buffer'da";
$content = ob_get_clean();

Sorunlar:

• OOP desteği hala çok zayıftı
• Objeler değer olarak kopyalanıyordu (referans değil)
• Namespace yoktu
• Exception handling yoktu

3. OOP Devrimi (2004-2009)

PHP 5.0 - 13 Temmuz 2004

Zend Engine 2.0 ile geldi. PHP'yi modern bir OOP diline dönüştürdü.

Devrim Niteliğinde Özellikler:

1. Gerçek OOP Desteği:

// Visibility modifiers
class User {
    private $password;
    protected $email;
    public $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    // Magic methods
    public function __toString() {
        return $this->name;
    }
}

// Inheritance
class Admin extends User {
    public function deleteUser() {
        // ...
    }
}

// Interfaces
interface Loggable {
    public function log($message);
}

// Abstract classes
abstract class BaseController {
    abstract public function handle();
}

2. Exception Handling:

try {
    throw new Exception("Bir hata oluştu");
} catch (Exception $e) {
    echo $e->getMessage();
} finally { // PHP 5.5'te eklendi
    // Cleanup
}

3. Type Hinting (sadece class ve array):

function processUser(User $user, array $options) {
    // ...
}

4. Diğer Özellikler:

• Objeler artık referans olarak geçiliyor
• Iterators ve SPL (Standard PHP Library)
• Reflection API
• SimpleXML
• MySQLi (MySQL Improved Extension)
• PDO (PHP Data Objects)

// PDO ile veritabanı
$pdo = new PDO('mysql:host=localhost;dbname=test', 'user', 'pass');
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = ?');
$stmt->execute([1]);

PHP 5.1 - 24 Kasım 2005

• PDO varsayılan olarak aktif
• Performans iyileştirmeleri
• DateTime sınıfı

PHP 5.2 - 2 Kasım 2006

• JSON desteği (json_encode, json_decode)
• Zip archive desteği
• Filter extension (input validation)
• Improved memory management

// JSON kullanımı
$data = ['name' => 'Ali', 'age' => 25];
$json = json_encode($data);
$decoded = json_decode($json, true);

PHP 5.3 - 30 Haziran 2009

Çok önemli bir versiyon. Modern PHP'nin gerçek başlangıcı.

Önemli Yenilikler:

1. Namespace:

namespace App\Models;

class User {
    // ...
}

// Kullanım
use App\Models\User;
$user = new User();

2. Late Static Binding:

class Parent {
    public static function who() {
        echo static::class; // PHP 5.3'te static::
    }
}

class Child extends Parent {}

Child::who(); // "Child" yazdırır

3. Closure (Anonim Fonksiyonlar):

$multiply = function($x, $y) {
    return $x * $y;
};

echo $multiply(3, 4); // 12

// use keyword ile dış scope'tan değişken kullanma
$factor = 10;
$multiplier = function($number) use ($factor) {
    return $number * $factor;
};

4. Diğer Özellikler:

• goto statement (tartışmalı)
• Nowdoc syntax (tek tırnaklı heredoc)
• __DIR__ magic constant
• Ternary shorthand: $x ?: 'default'
• Phar archives (PHP Archive)

PHP 5.4 - 1 Mart 2012

Gelen Özellikler:

1. Traits:

trait Logger {
    public function log($message) {
        echo $message;
    }
}

class User {
    use Logger;
}

$user = new User();
$user->log("Hello"); // Trait'ten gelen method

2. Short Array Syntax:

// Eski
$array = array(1, 2, 3);

// Yeni
$array = [1, 2, 3];
$assoc = ['name' => 'Ali', 'age' => 25];

3. Built-in Web Server:

php -S localhost:8000

4. Diğer Özellikler:

• Array dereferencing: function()[0]
• Callable type hint
• <?= always available (short echo tag)
• Binary number format: 0b001101
• Session upload progress

Çıkarılan Özellikler:

• register_globals - GÜVENLİK nedeniyle
• magic_quotes - GÜVENLİK nedeniyle
• safe_mode - GÜVENLİK nedeniyle

PHP 5.5 - 20 Haziran 2013

1. Generators:

function getNumbers() {
    for ($i = 0; $i < 1000; $i++) {
        yield $i; // Belleği şişirmeden büyük veri setleri
    }
}

foreach (getNumbers() as $number) {
    echo $number;
}

2. finally Block:

try {
    // kod
} catch (Exception $e) {
    // hata
} finally {
    // her durumda çalışır
}

3. Password Hashing API:

// Güvenli şifre hash'leme
$hash = password_hash("mypassword", PASSWORD_DEFAULT);
$verify = password_verify("mypassword", $hash);

4. Diğer:

• empty() ile expressions kullanımı
• Array and string literal dereferencing
• OPcache (APC'nin yerini aldı)
• ::class keyword

echo User::class; // "User" string'ini döner

PHP 5.6 - 28 Ağustos 2014

1. Variadic Functions:

function sum(...$numbers) {
    return array_sum($numbers);
}

echo sum(1, 2, 3, 4); // 10

2. Argument Unpacking:

$array = [1, 2, 3];
function add($a, $b, $c) {
    return $a + $b + $c;
}

echo add(...$array); // 6

3. Constant Expressions:

const ARRAY = [1, 2, 3];
const TWO = 1 + 1;

4. Diğer:

• Exponential operator: 2 ** 3 = 8
• use function ve use const
• Large file uploads (>2GB)
• phpdbg debugger

4. Modern PHP Çağı (2015-2020)

PHP 7.0 - 3 Aralık 2015

DEVASA PERFORMANS ARTIŞI - Zend Engine 3.0

Bu versiyon PHP tarihindeki en önemli sıçramalardan biri. %50-200 performans artışı ve %50 bellek kullanımı azalması.

Scalar Type Declarations:

function add(int $a, int $b): int {
    return $a + $b;
}

declare(strict_types=1); // Strict mode

Return Type Declarations:

function getUser(): ?User { // Nullable return
    return null;
}

function getData(): array {
    return [];
}

Null Coalescing Operator:

// Eski
$name = isset($_GET['name']) ? $_GET['name'] : 'Guest';

// Yeni
$name = $_GET['name'] ?? 'Guest';

Spaceship Operator:

echo 1 <=> 2; // -1
echo 2 <=> 2; // 0
echo 3 <=> 2; // 1

// Sorting'te kullanımı
usort($array, function($a, $b) {
    return $a <=> $b;
});

Anonymous Classes:

$logger = new class {
    public function log($message) {
        echo $message;
    }
};

Group Use Declarations:

use App\Models\{User, Post, Comment};

Diğer Özellikler:

• Unicode codepoint escape syntax: \u{1F602}
• Uniform variable syntax
• Throwable interface (Exception ve Error için ortak parent)
• Closure::call()

Çıkarılanlar:

• mysql extension (mysqli ve PDO kullanılmalı)
• ereg extension (preg kullanılmalı)
• $HTTP_RAW_POST_DATA
• ASP ve script PHP tags: <% %>, <script language="php">

PHP 7.1 - 1 Aralık 2016

Nullable Types:

function process(?string $name): ?int {
    return $name ? strlen($name) : null;
}

Void Return Type:

function log(string $message): void {
    echo $message;
}

Symmetric Array Destructuring:

// Short list syntax
[$a, $b] = [1, 2];

// Keyed arrays
['name' => $name, 'age' => $age] = $user;

Class Constant Visibility:

class User {
    private const SECRET = 'hidden';
    protected const CONFIG = 'protected';
    public const VERSION = '1.0';
}

Multi-catch:

try {
    // kod
} catch (TypeError | ValueError $e) {
    // Her ikisi için de aynı handler
}

Iterable Type:

function process(iterable $data): void {
    foreach ($data as $item) {
        // array veya Traversable kabul eder
    }
}

PHP 7.2 - 30 Kasım 2017

Object Type Hint:

function process(object $obj): object {
    return $obj;
}

Abstract Method Overriding:

abstract class A {
    abstract function test(string $s);
}

abstract class B extends A {
    // Parameter type'ı kaldırabilir (daha esnek)
    abstract function test($s): int;
}

Parameter Type Widening: Child class'larda parent'ın type hint'i kaldırılabilir.

Trailing Commas:

$array = [
    'first',
    'second',
    'third', // Son virgül artık izinli
];

Diğer:

• count() ile non-countable için warning
• Sodium extension (modern kriptografi)
• Argon2 password hashing

Deprecated:

• each() function
• (unset) cast
• __autoload() function

PHP 7.3 - 6 Aralık 2018

Flexible Heredoc/Nowdoc:

// Daha esnek indentation
function test() {
    return <<<'END'
        Bu artık
        daha esnek
        END;
}

Array Destructuring with Reference:

$array = [1, 2];
[&$a, $b] = $array;
$a = 10;
// $array artık [10, 2]

is_countable() Function:

if (is_countable($var)) {
    count($var);
}

Trailing Commas in Function Calls:

function test($a, $b, $c) {}

test(
    1,
    2,
    3, // Artık izinli
);

PHP 7.4 - 28 Kasım 2019

Bu versiyon modern PHP'nin temelini attı.

Typed Properties:

class User {
    public int $id;
    public string $name;
    public ?string $email = null;
    private array $roles;
    
    public function __construct(int $id) {
        $this->id = $id;
    }
}

Arrow Functions:

// Eski
$multiply = function($x) use ($factor) {
    return $x * $factor;
};

// Yeni (otomatik use)
$multiply = fn($x) => $x * $factor;

// Array fonksiyonlarında
$numbers = array_map(fn($n) => $n * 2, [1, 2, 3]);

Null Coalescing Assignment:

// Eski
$data['key'] = $data['key'] ?? 'default';

// Yeni
$data['key'] ??= 'default';

Array Spread Operator:

$array1 = [1, 2, 3];
$array2 = [4, 5];
$result = [...$array1, ...$array2]; // [1, 2, 3, 4, 5]

// Associative arrays (numeric keys için)
$array = ['a' => 1, ...['b' => 2]];

Numeric Literal Separator:

$number = 1_000_000; // Okunabilirlik için
$hex = 0xFF_FF_FF;

Weak References:

$obj = new stdClass;
$weakRef = WeakReference::create($obj);

Covariant Returns & Contravariant Parameters:

class Animal {}
class Dog extends Animal {}

class AnimalShelter {
    public function get(Dog $dog): Animal {
        return new Animal();
    }
}

class DogShelter extends AnimalShelter {
    // Covariant return: daha spesifik dönebilir
    public function get(Dog $dog): Dog {
        return new Dog();
    }
}

Preloading: Opcache'e dosyaları önceden yükleme - ciddi performans artışı.

Deprecated:

• Nested ternary without parentheses
• array_key_exists() ile objects

5. Modern PHP ve Tür Sistemi (2020-2024)

PHP 8.0 - 26 Kasım 2020

BÜYÜK YENİLİKLER DOLU VERSİYON

JIT (Just-In-Time) Compiler: Belirli senaryolarda %30-40 performans artışı.

Union Types:

function process(int|float $number): int|float {
    return $number * 2;
}

class Number {
    private int|float $value;
}

Named Arguments:

function createUser(
    string $name,
    string $email,
    bool $active = true,
    int $age = 18
) {}

// İstediğin parametreyi gönder
createUser(
    email: 'ali@example.com',
    name: 'Ali',
    age: 25
);

Attributes (Annotations):

#[Route('/users', methods: ['GET'])]
#[Authenticated]
class UserController {
    #[Cache(ttl: 3600)]
    public function index(): array {
        return [];
    }
}

// Reflection ile okuma
$attributes = (new ReflectionClass(UserController::class))
    ->getAttributes(Route::class);

Match Expression:

// Eski switch
switch ($status) {
    case 'draft':
        $message = 'Taslak';
        break;
    case 'published':
        $message = 'Yayında';
        break;
    default:
        $message = 'Bilinmeyen';
}

// Yeni match (daha güvenli, return eder)
$message = match($status) {
    'draft' => 'Taslak',
    'published' => 'Yayında',
    default => 'Bilinmeyen',
};

// Multiple conditions
$result = match($value) {
    1, 2, 3 => 'Küçük',
    4, 5, 6 => 'Orta',
    default => 'Büyük',
};

Constructor Property Promotion:

// Eski
class User {
    private string $name;
    private string $email;
    
    public function __construct(string $name, string $email) {
        $this->name = $name;
        $this->email = $email;
    }
}

// Yeni
class User {
    public function __construct(
        private string $name,
        private string $email,
    ) {}
}

Nullsafe Operator:

// Eski
$country = null;
if ($user !== null) {
    $address = $user->getAddress();
    if ($address !== null) {
        $country = $address->country;
    }
}

// Yeni
$country = $user?->getAddress()?->country;

Mixed Type:

function process(mixed $value): mixed {
    // Her şeyi kabul eder
    return $value;
}

Static Return Type:

class Model {
    public static function create(): static {
        return new static();
    }
}

Throw Expression:

$value = $input ?? throw new Exception('Input required');

$callback = fn() => throw new Exception('Not implemented');

Weak Maps:

$map = new WeakMap();
$obj = new stdClass;
$map[$obj] = 'data';
// $obj silindiğinde map'ten de silinir

Diğer:

• str_contains(), str_starts_with(), str_ends_with()
• get_debug_type() function
• ::class on objects

Çıkarılanlar/Deprecated:

• Birçok eski, güvenli olmayan özellik

PHP 8.1 - 25 Kasım 2021

Enums (Enumerations):

// Pure enum
enum Status {
    case Draft;
    case Published;
    case Archived;
}

$status = Status::Published;

// Backed enum (değer içerir)
enum Status: string {
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';
}

// Methods ve daha fazlası
enum Status: string {
    case Draft = 'draft';
    case Published = 'published';
    
    public function label(): string {
        return match($this) {
            self::Draft => 'Taslak',
            self::Published => 'Yayında',
        };
    }
}

$status = Status::from('draft'); // String'den enum

Readonly Properties:

class User {
    public function __construct(
        public readonly string $name,
        public readonly int $age,
    ) {}
}

$user = new User('Ali', 25);
$user->name = 'Veli'; // HATA! Readonly değiştirilemez

First-class Callable Syntax:

// Eski
$fn = Closure::fromCallable('strlen');
$fn = Closure::fromCallable([$obj, 'method']);

// Yeni
$fn = strlen(...);
$fn = $obj->method(...);

// Array functions ile
array_map(strtoupper(...), $strings);

Intersection Types:

interface Loggable {}
interface Cacheable {}

function process(Loggable&Cacheable $obj) {
    // $obj her iki interface'i de implement etmeli
}

New in Initializers:

class Service {
    public function __construct(
        private Logger $logger = new Logger(),
    ) {}
}

// Attribute'lerde de
#[Route(new PathPrefix('/api'))]
class ApiController {}

Pure Intersection Types:

function process((Countable&Iterator)|array $data) {
    // ...
}

Never Return Type:

function redirect(string $url): never {
    header("Location: $url");
    exit;
}

function throwException(): never {
    throw new Exception();
}

Final Class Constants:

class Config {
    final public const VERSION = '1.0';
}

class ExtendedConfig extends Config {
    public const VERSION = '2.0'; // HATA!
}

Explicit Octal Notation:

// Eski
$octal = 0755; // Karışık

// Yeni
$octal = 0o755; // Açık ve net

Fibers: Asenkron programlama için düşük seviye primitive:

$fiber = new Fiber(function (): void {
    $value = Fiber::suspend('İlk değer');
    echo "Devam ediyor: $value\n";
});

$fiber->start();
$fiber->resume('İkinci değer');

Diğer:

• Array unpacking with string keys
• array_is_list() function
• fsync(), fdatasync()

Deprecated:

• Passing null to non-nullable internal function parameters
• Serializable interface

PHP 8.2 - 8 Aralık 2022

Readonly Classes:

readonly class User {
    public function __construct(
        public string $name,
        public int $age,
    ) {}
    
    // Tüm property'ler otomatik readonly
}

Disjunctive Normal Form (DNF) Types:

// Karmaşık type combinations
function process((Countable&ArrayAccess)|null $data) {
    // ...
}

class Repository {
    private (PDO&Loggable)|(mysqli&Loggable)|null $connection;
}

True Type:

function isValid(): true {
    // Sadece true dönebilir, false dönemez
    return true;
}

Constants in Traits:

trait HasVersion {
    public const VERSION = '1.0';
    
    public function getVersion(): string {
        return self::VERSION;
    }
}

Deprecated Dynamic Properties:

// Artık deprecated
$obj = new stdClass;
$obj->dynamicProperty = 'value'; // Deprecated warning

// İzin vermek için
#[AllowDynamicProperties]
class MyClass {}

Diğer:

• Random Extension (modern rastgele sayı üretimi)
• mysqli_execute_query() function
• curl_upkeep()
• Sensitive parameter redaction

Deprecated:

• Dynamic properties (yukarıda belirtildi)
• utf8_encode() ve utf8_decode()
• ${var} string interpolation

PHP 8.3 - 23 Kasım 2023

Typed Class Constants:

class Config {
    public const string VERSION = '1.0';
    public const int MAX_USERS = 100;
    private const array SETTINGS = [];
}

Override Attribute:

class Parent {
    public function test(): void {}
}

class Child extends Parent {
    #[Override] // Parent'ta yoksa hata verir
    public function test(): void {}
}

Dynamic Class Constant Fetch:

class Config {
    const string DEFAULT = 'value';
}

$name = 'DEFAULT';
echo Config::{$name}; // Dynamic

Anonymous Readonly Classes:

$user = new readonly class('Ali', 25) {
    public function __construct(
        public string $name,
        public int $age,
    ) {}
};

json_validate() Function:

// JSON parse etmeden validation
if (json_validate($string)) {
    $data = json_decode($string);
}

Negative Array Indices:

$array = ['a', 'b', 'c'];
$array[-1] = 'd'; // Son eleman

Diğer:

• mb_str_pad() function
• stream_context_set_options() improvements
• Randomizer additions
• Command line linter supports multiple files

Deprecated:

• Implicitly nullable parameter declarations
• MT_RAND_PHP mode

PHP 8.4 - 21 Kasım 2024 (En Güncel)

Property Hooks:

class User {
    // Virtual property - backing field yok
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
    }
    
    // Lazy loading
    private array $data {
        get => $this->data ??= $this->loadData();
    }
    
    // Validation
    public int $age {
        set(int $value) {
            if ($value < 0) {
                throw new ValueError();
            }
            $this->age = $value;
        }
    }
}

Asymmetric Visibility:

class User {
    // Public okunabilir, private yazılabilir
    public private(set) string $name;
    
    // Protected set
    public protected(set) int $age;
    
    public function __construct(string $name) {
        $this->name = $name; // Sadece sınıf içinde
    }
}

$user = new User('Ali');
echo $user->name; // OK
$user->name = 'Veli'; // HATA!

new Without Parentheses:

// Eski
$request = (new Request())->withMethod('POST');

// Yeni
$request = new Request()->withMethod('POST');

HTML5 Support in DOM:

$dom = DOM\HTMLDocument::createFromString($html, LIBXML_NOERROR);

Array Find Functions:

$array = [1, 2, 3, 4, 5];

// İlk eşleşeni bul
$first = array_find($array, fn($n) => $n > 2); // 3

// İlk key'i bul
$key = array_find_key($array, fn($n) => $n > 2); // 2

// any/all
$hasEven = array_any($array, fn($n) => $n % 2 === 0); // true
$allEven = array_all($array, fn($n) => $n % 2 === 0); // false

#[Deprecated] Attribute:

class OldClass {
    #[Deprecated(
        message: "Use NewClass instead",
        since: "2.0"
    )]
    public function oldMethod(): void {}
}

Lazy Objects:

// Proxy pattern için built-in destek
$user = new ReflectionClass(User::class)
    ->newLazyProxy(function() {
        return new User();
    });

Diğer:

• request_parse_body() function
• PDO driver-specific subclasses
• OpenSSL EC key support
• bcround(), bcfloor(), bcceil() functions

Özet: PHP'nin Evrimi

Önemli Dönüm Noktaları:

1. PHP 3 (1997): Gerçek programlama dili
2. PHP 4 (2000): Zend Engine, session, performance
3. PHP 5 (2004): Gerçek OOP
4. PHP 5.3 (2009): Namespace, closure - Modern PHP başlangıcı
5. PHP 7 (2015): Devasa performans artışı, scalar types
6. PHP 8 (2020): JIT, union types, attributes
7. PHP 8.1 (2021): Enums, readonly
8. PHP 8.4 (2024): Property hooks, asymmetric visibility

Genel Trendler:

• Performans: Her versiyonda sürekli iyileşme
• Tür Güvenliği: Gitgide güçlenen type system
• Modern OOP: C#/Java benzeri özelliklere yakınsama
• Güvenlik: Tehlikeli özelliklerin kaldırılması
• Developer Experience: Daha az kod, daha çok ifade gücü

PHP artık eski "kötü" imajından çok uzak, modern, güvenli ve performanslı bir dil haline gelmiş durumda.