PHP Kodlama Standartları (PSR)

PHP kodlama standartları, genellikle birlikte çalışan geliştiricilerin kodu daha okunabilir, anlaşılır ve sürdürülebilir hale getirmek amacıyla belirlenen kurallar ve yönergelerdir. PHP-FIG (PHP Framework Interop Group) tarafından oluşturulan PSR (PHP Standard Recommendations) dokümanları, PHP topluluğunda geniş bir kabul görmüş kodlama standartları sunar.

PSR’lerin zamanla değiştirildiğini, kullanımdan kaldırıldığını veya birbirlerinin yerine geçtiğini unutmayın. Güncel ACCEPTED PSR serisine PHP-FIG resmi sitesinden ulaşabilirsiniz. https://www.php-fig.org/psr/

PSR-1, Temel Kodlama Standartları

PSR-1, temel kodlama standartlarını belirler ve bu standartlara uymayı gerektirir. PSR-1’in bazı ana kuralları:

• Dosya isimleri CamelCase olmalıdır.
• PHP dosyaları sadece PHP kodu içermelidir ve başka çıktı üretmemelidir (örneğin, echo, print gibi).
• Dosyalar UTF-8 karakter setinde kodlanmalıdır ve herhangi bir Byte Order Mark (BOM) içermemelidir.

Örnek bir PSR-1 uyumlu PHP dosyası şu şekilde olabilir:

<?php

namespace MyNamespace;

class MyClass {
    public function myMethod() {
        // kod buraya gelecek
    }
}

Bu örnekte, dosya ismi CamelCase (MyClass.php), sadece PHP kodu içeriyor ve UTF-8 karakter setinde kodlanmıştır.

PSR-3, Logger Interface

Bu standart, PHP uygulamalarında loglama işlemleri için bir arayüz tanımlar ve bu sayede farklı loglama kütüphanelerinin birbiriyle uyumlu bir şekilde kullanılmasını sağlar.

PSR-3’ün temel amacı, loglama işlemlerini standart bir arayüz üzerinden gerçekleştirmek ve bu sayede farklı loglama kütüphanelerini kolayca değiştirebilme veya bir arada kullanabilme imkanı sunmaktır.

PSR-3, Psr\Log\LoggerInterface adlı bir arayüzü tanımlar. Bu arayüz, emergency, alert, critical, error, warning, notice, info ve debug gibi seviyelerde loglama metodlarını içerir.

İşte PSR-3’ün temel metotları:

• emergency($message, array $context = array())
• alert($message, array $context = array())
• critical($message, array $context = array())
• error($message, array $context = array())
• warning($message, array $context = array())
• notice($message, array $context = array())
• info($message, array $context = array())
• debug($message, array $context = array())

Örnek bir PSR-3 kullanımı şu şekildedir:

<?php

use Psr\Log\LoggerInterface;

class MyLogger implements LoggerInterface {
  
    public function emergency($message, array $context = array()) {
        // emergency seviyesinde loglama işlemleri burada yapılır
    }

    public function alert($message, array $context = array()) {
        // alert seviyesinde loglama işlemleri burada yapılır
    }

    // Diğer log seviyeleri için benzer metotlar eklenir.
}

// Kullanım örneği:
$logger = new MyLogger();
$logger->error('Bu bir hata mesajıdır.', ['error_code' => 500]);

PSR-4, Autoloading Standard

Bu standart, PHP tabanlı projelerde otomatik yüklenen sınıfların dosya yapısını düzenlemek ve standartlaştırmak amacıyla oluşturulmuştur. PSR-4, sınıfların ad alanlarına (namespace) dayalı olarak otomatik olarak yüklenmesini destekleyen bir autoload mekanizması tanımlar.

PSR-4 standartlarına göre, bir sınıfın ad alanı ile dosya yolu arasında birebir bir ilişki bulunmalıdır. Örneğin, Vendor\Package\ClassName sınıfı için dosya yolu vendor/package/ClassName.php olmalıdır.

Aşağıda, PSR-4 standartlarına uygun bir örnek gösterilmektedir:

Proje yapısı:

project/
|-- src/
|   |-- MyNamespace/
|       |-- MyClass.php
|-- vendor/
|-- composer.json

composer.json dosyası:

{
    "autoload": {
        "psr-4": {
            "MyNamespace\\": "src/"
        }
    }
}

Bu örnekte, MyNamespace ad alanı altında bulunan sınıfların dosyaları src/ dizini içinde yer almalıdır. Örneğin, MyClass sınıfının dosya yolu src/MyNamespace/MyClass.php olacaktır. Composer, otomatik yükleyiciyi bu bilgileri kullanarak oluşturur ve projenin ihtiyaç duyduğu sınıfları otomatik olarak yükler.

PSR-6, Caching Interface

PSR-6, önbellek nesneleri için bir arayüz (interface) tanımlar ve bu arayüzü uygulayan önbellek sürücülerinin ortak bir şekilde kullanılabilmesini sağlar. Bu sayede, farklı PHP projelerinde aynı önbellek sürücüsünü kullanmak mümkün hale gelir ve bu da kod taşınabilirliğini artırır.

// PSR-6 uyumlu bir önbellek sürücüsü örneği

use Psr\Cache\CacheItemPoolInterface;
use Psr\Cache\CacheItemInterface;

class MyCache implements CacheItemPoolInterface
{
    private $cache = [];

    public function getItem($key)
    {
        if (isset($this->cache[$key])) {
            return $this->cache[$key];
        }

        $item = new MyCacheItem($key);
        $this->cache[$key] = $item;

        return $item;
    }

    public function getItems(array $keys = [])
    {
        $items = [];
        foreach ($keys as $key) {
            $items[] = $this->getItem($key);
        }

        return $items;
    }

    public function hasItem($key)
    {
        return isset($this->cache[$key]);
    }

    // Diğer PSR-6 yöntemlerini uygulamak gerekir

    // ...
}

class MyCacheItem implements CacheItemInterface
{
    private $key;
    private $value;
    private $isHit = false;

    public function __construct($key)
    {
        $this->key = $key;
    }

    public function getKey()
    {
        return $this->key;
    }

    public function get()
    {
        return $this->isHit ? $this->value : null;
    }

    public function set($value)
    {
        $this->value = $value;
        $this->isHit = true;
    }

    // Diğer PSR-6 CacheItemInterface yöntemlerini uygulamak gerekir

    // ...
}

Bu örnekte, MyCache sınıfı PSR-6’nın CacheItemPoolInterface arayüzünü uygular ve temel önbellek işlemlerini gerçekleştirir. MyCacheItem sınıfı ise CacheItemInterface arayüzünü uygular ve tek bir önbellek öğesini temsil eder.

PSR-7, HTTP Message Interface

Bu standart, HTTP mesajları için bir arabirim tanımlar. PSR-7’nin temel amacı, HTTP isteklerini ve cevaplarını temsil etmek için bir standart oluşturarak farklı PHP tabanlı web uygulama çerçeveleri ve kütüphaneleri arasında uyumluluk sağlamaktır.

PSR-7, HTTP isteği ve cevabını temsil etmek için iki ana sınıf içerir: ServerRequestInterface ve ResponseInterface. Bu arabirimler, HTTP iletişimi sırasında kullanılan bilgileri standartlaştırır ve böylece farklı uygulamalar arasında daha kolay entegrasyon sağlar.

İşte PSR-7’nin temel arabirimlerinden biri olan RequestInterface‘in örnek bir kullanımı:

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;

// Örnek bir HTTP isteği oluşturmak
$request = new \GuzzleHttp\Psr7\ServerRequest('GET', 'http://example.com/path', 
                                              ['User-Agent' => 'MyApp']);

// Örnek bir HTTP cevabı oluşturmak
$response = new \GuzzleHttp\Psr7\Response(200, ['Content-Type' => 'text/html'], 
                                          'Hello, World!');

// PSR-7 arabirimlerini kullanarak çalışmak
function processRequest(ServerRequestInterface $request): ResponseInterface {
    // İşleme kodu buraya gelecek
    // ...
    // Örnek bir cevap döndürmek
    return new \GuzzleHttp\Psr7\Response(200, [], 'Response Content');
}

// İşlenmiş isteği almak
$result = processRequest($request);

// Cevabı kullanmak
echo $result->getBody(); // Çıktı: Response Content

Bu örnek, PSR-7 standartlarına uygun bir HTTP isteği ve cevabı nasıl oluşturulacağını göstermektedir. Bu standartlar, farklı kütüphaneler ve çerçeveler arasında uyumluluk sağlayarak, kodun taşınabilir ve yeniden kullanılabilir olmasına yardımcı olur.

PSR-11, Container Interface

Servis konteyneri, uygulama içinde kullanılan nesnelerin (objelerin) yönetimini ve bu nesneler arasındaki bağımlılıkları çözmeyi sağlayan bir yapıdır. PSR-11, bu tür servis konteynerlerinin nasıl olması gerektiğini belirleyen bir standarttır.

PSR-11, bir servis konteynerini temsil eden ContainerInterface adlı bir arabirim (interface) içerir. Bu arabirim, servisleri almak için get metodunu ve belirli bir servisin mevcut olup olmadığını kontrol etmek için has metodunu tanımlar.

PSR-11 uyumlu servis konteyneri örneği:

use Psr\Container\ContainerInterface;

class SomeService
{
    private $dependency;

    public function __construct(ContainerInterface $container)
    {
        // PSR-11 ile bağımlılık enjeksiyonu
        $this->dependency = $container->get('SomeDependency');
    }

    public function doSomething()
    {
        // $this->dependency üzerinde işlemler yapabilirsiniz
        // ...
    }
}

Bu örnekte, SomeService sınıfının bağımlılıkları, ContainerInterface arayüzü aracılığıyla enjekte ediliyor. Bu sayede uygulamanızın bağımlılıklarını daha kolay yönetebilir ve değiştirebilirsiniz. Gerçek bir uygulama senaryosunda, ContainerInterface‘i implement eden bir bağımlılık enjeksiyonu konteyneri (örneğin, Symfony Container Component) kullanılır.

PSR-12, Extended Coding Style Guide

PSR-12, PHP dilinde kod yazımı için bir standart belirtir. Bu standart, kodun okunabilirliğini artırmak, tutarlılık sağlamak ve farklı geliştiriciler arasında kodun anlaşılabilirliğini artırmak için belirli kuralları içerir.

PSR-12, kodun düzenlenmesi, boşluk kullanımı, parantez yerleşimi gibi konularda belirli kurallar getirir. Aşağıda PSR-12’ye uygun bir PHP kodu örneği bulunmaktadır:

<?php

namespace Uygulama\Modul;

use Başka\Namespace\ClassA;
use Başka\Namespace\ClassB as BClass;

class UygulamaClass extends BaseClass implements InterfaceA, InterfaceB
{
    private $ornek;

    public function __construct($ornek)
    {
        $this->ornek = $ornek;
    }

    public function getOrnek()
    {
        return $this->ornek;
    }

    public function setOrnek($ornek)
    {
        $this->ornek = $ornek;
    }

    public function ornekMetod()
    {
        if ($this->ornek) {
            return 'Bu bir örnek.';
        } else {
            return 'Örnek bulunamadı.';
        }
    }
}

Bu örnek, PSR-12 standartlarına uygun bir PHP sınıfını gösterir. Bu standartlar, kodun daha okunabilir ve tutarlı olmasını sağlamak için belirli stil yönergeleri getirir.

PSR-13, Hypermedia Links

PSR-13, URL’leri temsil etmek için bir standart tanımlar. Tam olarak “PSR-13: Link URL Interface” olarak adlandırılır.

Bu belge, URL’leri tek bir nesne aracılığıyla temsil etmek için bir arabirim (interface) tanımlar. PSR-13’e uyan bir sınıf, bir URL’nin farklı bileşenlerini (scheme, host, path, query string, vb.) bir araya getirebilir ve bu bilgileri kullanıcıya sunabilir.

İşte PSR-13’e uyan bir örnek:

<?php

use Psr\Http\Message\UriInterface;

class MyUri implements UriInterface
{
    // Sınıfın UriInterface arabirimini uygulayacak şekilde gerekli metotları içerir.

    public function getScheme()
    {
        // URL'nin şemasını döndürür.
    }

    public function getHost()
    {
        // URL'nin ana bilgisayarını döndürür.
    }

    // Diğer gerekli metotlar da burada yer alır.
}

// PSR-13'e uyan sınıfın kullanımı
$uri = new MyUri('https://www.example.com/path?query=value');
echo $uri->getScheme(); // "https"
echo $uri->getHost(); // "www.example.com"

Bu örnek, PSR-13 arabirimini uygulayan bir MyUri sınıfını göstermektedir. Sınıf, bir URL’nin bileşenlerini sağlamak için gerekli metotları içermelidir. PSR-13’ün amacı, farklı PHP kütüphaneleri ve çerçeveleri arasında URL temsilini standartlaştırmaktır.

PSR-14, Event Dispatcher

PSR-14, “Event Dispatcher” olarak adlandırılan bir olay yönetim sistemini tanımlar. Bu, bir uygulama içinde gerçekleşen olayları dinlemek ve tepki vermek için bir mekanizma sağlar. PSR-14’e uyan bir uygulama, olayları yayınlayabilir (dispatch) ve olayları dinleyen (listener) sınıflar tarafından işlenebilir.

İşte PSR-14 ile ilgili basit bir örnek:

// Olayı temsil eden bir sınıf
class SampleEvent {
    private $data;

    public function __construct($data) {
        $this->data = $data;
    }

    public function getData() {
        return $this->data;
    }
}

// Olay dinleyici (listener) sınıf
class SampleListener {
    public function handleEvent(SampleEvent $event) {
        $data = $event->getData();
        echo "Olay yakalandı! Veri: $data\n";
    }
}

// Olay yöneticisi (dispatcher) oluşturulması
$dispatcher = new \Symfony\Component\EventDispatcher\EventDispatcher();

// Olay dinleyicisinin eklenmesi
$listener = new SampleListener();
$dispatcher->addListener(SampleEvent::class, [$listener, 'handleEvent']);

// Olayın yayınlanması (dispatch)
$event = new SampleEvent("Merhaba, PSR-14!");
$dispatcher->dispatch($event);

Bu örnekte, SampleEvent sınıfı bir olayı temsil eder ve SampleListener sınıfı bu olayı dinler. EventDispatcher sınıfı ise olayları yönetir. Olay yayınlandığında (dispatch edildiğinde), ilgili dinleyici tarafından belirtilen işlemler gerçekleştirilir. Bu örnekte, olayın verisi ekrana yazdırılır.

PSR-15, HTTP Handlers

PSR-15, HTTP sunucu taleplerini ve cevaplarını işlemek için bir arayüz belirler. Bu standart, HTTP taleplerini ve cevaplarını birbirinden bağımsız nesneler olarak ele almayı ve bu nesnelerin işlenmesini modüler hale getirmeyi amaçlar. Bu, özellikle PHP tabanlı web uygulamaları geliştiren geliştiriciler için faydalıdır, çünkü bu standart sayesinde middleware’lerin daha kolay bir şekilde bir araya getirilip kullanılmasını sağlar.

PSR-15, iki ana arayüzden oluşur: ServerRequestInterface ve ResponseInterface.

İşte PSR-15’in temel arayüzleri ve bu arayüzleri uygulayan bir örnek sınıf:

1. ServerRequestInterface:

• HTTP taleplerini temsil eden bir arayüzdür.
• İlgili metotlar aracılığıyla taleplerin bilgilerine ve özelliklerine erişim sağlar.

<?php

namespace Psr\Http\Message;

interface ServerRequestInterface extends RequestInterface
{
    // Server request specific methods
    public function getServerParams();
    public function getCookieParams();
    public function withCookieParams(array $cookies);
    // ... diğer metotlar ...
}

2. ResponseInterface:

• HTTP cevaplarını temsil eden bir arayüzdür.
• İlgili metotlar aracılığıyla cevapların bilgilerine ve özelliklerine erişim sağlar.

<?php

namespace Psr\Http\Message;

interface ResponseInterface extends MessageInterface
{
    // Response specific methods
    public function getStatusCode();
    public function withStatus($code, $reasonPhrase = '');
    public function getReasonPhrase();
    // ... diğer metotlar ...
}

Bu arayüzleri uygulayan bir örnek sınıf:

<?php

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;

class MyMiddleware
{
    public function __invoke(ServerRequestInterface $request, 
                             ResponseInterface $response, callable $next)
    {
        // Middleware logic
        // ...

        // Pass the request and response to the next middleware in the stack
        return $next($request, $response);
    }
}

Bu örnekte, MyMiddleware adlı sınıf PSR-15 arayüzlerini uygular ve bir HTTP talebini ve cevabını işlemek için bir middleware olarak kullanılabilir.

PSR-16, Simple Cache

PSR-16, PHP uygulamalarında önbellek kullanımını standartlaştırmayı amaçlar.

PSR-16, önbellek ile ilgili işlemleri gerçekleştirmek için kullanılabilecek bir dizi metodu belirler. Bu metotlar arasında önbellekten veri okuma, veri yazma, belirli bir anahtarı kontrol etme, belirli bir anahtarı silme gibi temel önbellek işlemleri bulunur.

Aşağıda PSR-16’nın temel metotlarından birkaçı ile ilgili örnek bir PHP kodu bulunmaktadır:

<?php

// PSR-16 uyumlu bir önbellek örneği oluşturun
$cache = new \Psr\SimpleCache\CacheInterface();

// Veri önbelleğe ekleme
$cache->set('anahtar', 'değer', 3600); // 3600 saniye (1 saat) süreyle önbellekte sakla

// Veriyi önbellekten alma
$value = $cache->get('anahtar');

if ($value !== null) {
    echo "Önbellekten alınan değer: " . $value;
} else {
    echo "Önbellekte bulunamayan bir anahtar";
}

// Belirli bir anahtarı önbellekten silme
$cache->delete('anahtar');

// Belirli bir anahtarın önbellekte olup olmadığını kontrol etme
if ($cache->has('anahtar')) {
    echo "Önbellekte bulunan bir anahtar";
} else {
    echo "Önbellekte bulunmayan bir anahtar";
}
?>

Bu örnekte, set, get, delete ve has gibi temel metotlar kullanılarak önbellek işlemleri gerçekleştirilmektedir. Bu metotlar, PSR-16 uyumlu bir önbellek uygulamasının temel işlevselliğini sağlar. Ancak, gerçek bir uygulamada bu metotlar bir önbellek uygulamasına özgü şekilde uygulanmalıdır.

PSR-17, HTTP Factories

PSR-17, HTTP mesajları için fabrikaları tanımlar. PSR-7, PSR-15 gibi diğer PSR’lerle birlikte kullanılarak HTTP tabanlı uygulamaların oluşturulmasını kolaylaştırmak amacıyla geliştirilmiştir.

PSR-17’nin odaklandığı ana nokta, HTTP mesajları için nesnelerin oluşturulmasıdır. Özellikle, PSR-17, HTTP isteklerini ve yanıtlarını oluşturmak için kullanılan fabrikaları tanımlar.

Aşağıda, PSR-17’nin HTTP mesajı fabrikalarını tanımlayan bir örnek bulunmaktadır:

<?php

use Psr\Http\Message\UriFactoryInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\ResponseFactoryInterface;

class HttpMessageFactory implements
    UriFactoryInterface,
    StreamFactoryInterface,
    RequestFactoryInterface,
    ResponseFactoryInterface
{
    public function createUri(string $uri = ''): UriInterface
    {
        return new Uri($uri);
    }

    public function createStream(string $content = ''): StreamInterface
    {
        return new Stream($content);
    }

    public function createRequest(string $method, $uri): RequestInterface
    {
        return new Request($method, $uri);
    }

    public function createResponse(int $code = 200, string $reasonPhrase = ''): ResponseInterface
    {
        return new Response($code, $reasonPhrase);
    }
}

// Kullanım örneği:
$httpMessageFactory = new HttpMessageFactory();

$uri = $httpMessageFactory->createUri('https://example.com');
$request = $httpMessageFactory->createRequest('GET', $uri);
$response = $httpMessageFactory->createResponse(200, 'OK');

// Oluşturulan nesneleri kullanabilirsiniz.

Bu örnek, PSR-17’nin tanımladığı UriFactoryInterface, StreamFactoryInterface, RequestFactoryInterface, ve ResponseFactoryInterface arabirimlerini uygular ve ilgili HTTP mesajı nesnelerini oluşturmak için kullanılır.

PSR-18, HTTP Client

PSR-18, HTTP istemcilerinin nasıl olması gerektiği konusunda bir rehber sağlar, bu da farklı PHP projeleri arasında daha iyi bir etkileşim ve uyumluluk sağlar.

PSR-18’in temel amacı, HTTP istemcisi uygulamalarının birbirine entegrasyonunu ve değiştirilebilirliğini artırmaktır. Standardın uygulandığı bir HTTP istemcisi, belirli bir proje içinde kolayca değiştirilebilmeli ve diğer PSR-18 uyumlu kütüphanelerle sorunsuz bir şekilde çalışabilmelidir.

PSR-18 ile bir HTTP istemcisi, PSR-7 uyumlu HTTP istek ve cevap nesneleri ile etkileşimde bulunmalıdır. PSR-7, HTTP mesajları için bir standart tanımlar.

İşte PSR-18’i uygulayan bir HTTP istemcisi örneği:

use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

class MyHttpClient implements ClientInterface
{
    public function sendRequest(RequestInterface $request): ResponseInterface
    {
        // HTTP isteğini gönder ve cevabı al
        // Örneğin, Guzzle, Symfony HttpClient veya diğer bir HTTP istemci kütüphanesi kullanılabilir

        // Burada sadece basit bir örnek:
        $httpClient = new \GuzzleHttp\Client();
        $guzzleResponse = $httpClient->send($request);

        // Guzzle'dan alınan cevabı PSR-7 uyumlu hale getir
        $response = new \GuzzleHttp\Psr7\Response(
            $guzzleResponse->getStatusCode(),
            $guzzleResponse->getHeaders(),
            $guzzleResponse->getBody(),
            $guzzleResponse->getProtocolVersion(),
            $guzzleResponse->getReasonPhrase()
        );

        return $response;
    }
}

// Kullanım örneği
$request = new \GuzzleHttp\Psr7\Request('GET', 'https://example.com');
$httpClient = new MyHttpClient();
$response = $httpClient->sendRequest($request);

// Cevabı kullan
echo $response->getBody();

Bu örnek, PSR-18 standardını uygulayan bir HTTP istemcisi sınıfını gösterir. Ancak, gerçek bir uygulama için genellikle popüler HTTP istemci kütüphaneleri (örneğin, Guzzle, Symfony HttpClient) kullanılır ve bu kütüphaneler genellikle PSR-18 uyumlu oldukları için ayrıca bir uygulama yapmanıza gerek kalmayabilir.

Share on Facebook

Tweet