PHP’de Global Fonksiyon Çözümü: strlen() mu, \strlen() mu?

PHP’de bazen başlangıçta gereksiz bir detay gibi görünen bazı kurallar vardır. Örneğin, aşağıdaki iki kod parçası arasında ciddi bir farktır:

strlen($name);

Bazı projelerde ise fonksiyon şöyle yazılır:

\strlen($name);

İlk başta her ikisinin de aynı sonucu verdiği düşünülebilir, ancak burada namespace içindeki fonksiyon çözümleme davranışı önem kazanmaktadır. Bu konu, framework, package veya performans hassasiyeti gerektiren kodlar yazarken kritik bir öneme sahip oluyor.

Kısa Cevap

PHP’de namespaced bir dosya içindeyseniz:

namespace App\Services;

strlen($value);

PHP önce şu fonksiyonu arar:

App\Services\strlen()

Eğer bulamazsa, global namespace’e düşer ve şu fonksiyonu çalıştırır:

strlen()

Şayet şöyle yazarsanız:

\strlen($value);

PHP doğrudan global namespace’teki strlen fonksiyonunu çağırır. Yani:

strlen()

Ve aynı şekilde:

\strlen()

Çoğu durumda aynı sonucu üretir, fakat çözümleme yolları farklıdır.

Namespace İçinde Fonksiyon Çağırmak

İşte bir örnek:

namespace App\Support;

function example(string $text): int
{
    return strlen($text);
}

Buradaki strlen() çağrısı global bir PHP fonksiyonu gibi görünse de, PHP bu fonksiyonu doğrudan global bir strlen() olarak yorumlamaz. Önce mevcut namespace içinde fonksiyon arar:

App\Support\strlen()

Eğer böyle bir fonksiyon yoksa, PHP fallback yapar ve global fonksiyonu çağırır:

strlen()

Bu yüzden kod çalışır.

Peki \strlen() Ne Yapar?

Başına \ koyduğumuzda PHP’ye şunu söylemiş oluruz:

Bu fonksiyonu mevcut namespace içinde arama. Direkt global namespace’ten çağır.

Örnek:

namespace App\Support;

function example(string $text): int
{
    return \strlen($text);
}

Burada PHP doğrudan global strlen() fonksiyonuna gider. Yani namespace fallback mekanizmasına hiç girmez.

Farkı Daha Net Görelim

Şöyle bir kod düşünelim:

namespace App\Support;

function strlen(string $value): int
{
    return 999;
}

function test(): void
{
    echo strlen('Barış');
}

Çıktı:

999

Çünkü strlen() çağrısı önce mevcut namespace içinde aranır ve App\Support\strlen() bulunduğu için o çalışır.

Ama şöyle yazarsak:

namespace App\Support;

function strlen(string $value): int
{
    return 999;
}

function test(): void
{
    echo \strlen();
}

Çıktı:

6

Çünkü \strlen() doğrudan global PHP fonksiyonunu çağırır. Buradaki 6, "Barış" string’inin byte uzunluğudur.

Bu Davranış Sadece Fonksiyonlarda Mı Var?

PHP’de namespace çözümleme davranışı fonksiyonlar, sabitler ve class’lar için farklı çalışır. Fonksiyonlarda fallback vardır:

namespace App;

strlen();

PHP önce App\strlen() arar, bulamazsa global strlen() fonksiyonuna gider.

Sabitlerde de benzer fallback davranışı vardır:

namespace App;

echo PHP_VERSION;

PHP önce App\PHP_VERSION arayabilir, sonra global PHP_VERSION sabitine düşebilir. Ama class’larda durum farklıdır:

namespace App;

$date = new DateTime();

Bu kod global DateTime sınıfını otomatik bulmaz. PHP bunu şöyle yorumlar:

App\DateTime

Bu yüzden doğru kullanım şudur:

$date = new \DateTime();

Ya da:

use DateTime;

$date = new DateTime();

Bu ayrım önemlidir. Fonksiyonlarda global fallback varken, class’larda aynı rahatlık yoktur.

Neden Bazı Projeler \strlen() Kullanır?

Bunun birkaç sebebi var.

Açık Niyet

\strlen($value);

Bu açıkça şunu söyler:

Ben PHP’nin global built-in fonksiyonunu çağırıyorum.

Bu, özellikle framework, SDK veya package geliştirirken güzel bir sinyaldir. Örneğin:

namespace Vendor\Package;

final class StringHelper
{
    public static function length(string $value): int
    {
        return \strlen($value);
    }
}

Burada \strlen() kullanmak, kodu okuyan kişiye “bu global PHP fonksiyonu” mesajını net verir.

Namespace İçinde Aynı İsimli Fonksiyonlardan Etkilenmemek

Bir namespace içinde aynı isimde fonksiyon tanımlanmış olabilir:

namespace App\Support;

function time(): int
{
    return 123456;
}

Bu durumda:

time();

Çağrısı App\Support\time() fonksiyonunu çalıştırır. Ama:

\time();

Global PHP time() fonksiyonunu çağırır. Bu, özellikle testlerde veya özel helper fonksiyonlarında fark yaratabilir.

Çok Küçük Performans Farkı

Geçmişte \strlen() gibi fully-qualified global function çağrılarının daha doğrudan çözümlendiği için küçük performans avantajı sağlayabileceği konuşulurdu. Modern PHP sürümlerinde OPcache ve engine optimizasyonları sayesinde bu fark çoğu uygulamada pratik olarak önemsizdir. Yani normal bir Laravel projesinde:

strlen($name);

Bunun yerine her yerde:

\strlen($name);

Yazmak büyük bir performans mucizesi yaratmaz. Ama düşük seviyeli bir package, yüksek frekanslı bir parser, serializer, validator veya framework core kodu yazıyorsanız \strlen(), \is_array(), \count(), \sprintf() gibi kullanımlar tercih edilebilir.

use function Alternatifi

PHP’de fonksiyonları import etmek de mümkündür:

namespace App\Support;

use function strlen;
use function array_filter;

function example(array $items, string $name): array
{
    $length = strlen($name);

    return array_filter($items);
}

Bu kullanım da niyeti açık hale getirir.

Daha okunabilir bir örnek:

namespace App\Support;

use function is_string;
use function trim;
use function strlen;

final class UsernameValidator
{
    public function validate(mixed $value): bool
    {
        return is_string($value)
            && strlen(trim($value)) >= 3;
    }
}

Burada fonksiyonların global PHP fonksiyonları olduğu belirgin şekilde belirtilmiş olur. Ancak pratikte çoğu PHP/Laravel projesinde bu kadar detaylı import kullanılmaz.

Laravel Projelerinde Ne Yapmalı?

Laravel tarafında günlük uygulama kodunda şu kullanım gayet normaldir:

if (strlen($request->name)  3) {
    // ...
}

Bunu illa şöyle yazmak zorunda değilsiniz:

if (\strlen($request->name)  3) {
    // ...
}

Pratik önerim şudur: Basit application code içinde okunabilirliği bozmayacak şekilde normal kullanım yeterlidir:

count($items);
is_array($value);
trim($name);

Ama reusable package, framework-level helper, performans hassas kod veya namespace çakışması ihtimali olan bir yerde fully-qualified kullanım daha temiz olabilir:

\count($items);
\is_array($value);
\trim($name);

Yani mesele “her zaman böyle yaz” değil; kodun bağlamına göre doğru seçimi yapmak.

Testlerde Bu Davranış İşe Yarabilir

Namespace function resolution bazen testlerde bilinçli olarak kullanılabilir. Örneğin production kodunda şöyle bir kullanım var diyelim:

namespace App\Services;

final class TokenGenerator
{
    public function generate(): string
    {
        return bin2hex(random_bytes(16));
    }
}

Burada random_bytes() unqualified çağrılmıştır. Test ortamında aynı namespace altında özel bir fonksiyon tanımlayarak bu davranışı kontrol etmek teorik olarak mümkündür:

namespace App\Services;

function random_bytes(int $length): string
return str_repeat(, $length);
}

Bu durumda App\Services namespace’i içindeki random_bytes() çağrısı önce bu fonksiyona bakabilir. Ama production kodunda şöyle yazılmış olsaydı:

return \bin2hex(\random_bytes(16));

Artık namespace içindeki override devreye girmezdi. Çünkü çağrı doğrudan global fonksiyona giderdi. Bu teknik her projede önerilecek bir yöntem değildir, ama PHP’nin fonksiyon çözümleme mantığını anlamak açısından güzel bir örnektir.