PHP’de bazen şöyle kodlar görürüz:

strlen($name);

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

\strlen($name);

İlk bakışta gereksiz bir detay gibi görünebilir. Sonuçta ikisi de string uzunluğu hesaplıyor, değil mi?

Evet, çoğu zaman sonuç aynı olur. Ama PHP’nin namespace içindeki fonksiyon çözümleme davranışını bilirsek, bu küçük farkın neden ortaya çıktığını daha iyi anlarız.

Bu konu özellikle framework, package, library veya performans hassasiyeti olan kodlar yazarken önem kazanır.

Kısa cevap

PHP’de namespaced bir dosya içindeysen:

namespace App\Services;

strlen($value);

PHP önce şu fonksiyonu arar:

App\Services\strlen()

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

strlen()

Ama şöyle yazarsan:

\strlen($value);

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

Yani:

strlen()

ile

\strlen()

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

Namespace içinde fonksiyon çağırmak

Şu örneğe bakalım:

<?php

namespace App\Support;

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

Buradaki strlen() çağrısı global PHP fonksiyonu gibi görünür. Ama PHP bunu doğrudan global strlen() olarak okumaz.

Ö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:

<?php

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:

<?php

namespace App\Support;

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

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

Çıktı:

6

Çünkü \strlen() doğrudan global PHP fonksiyonunu çağırır.

Buradaki 6, "Barış" string’inin byte uzunluğudur. Türkçe karakterlerden dolayı karakter sayısı ile byte sayısı farklı olabilir. Karakter sayısı gerekiyorsa mb_strlen() kullanmak daha doğru olur.

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('test');

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();

veya:

use DateTime;

$date = new DateTime();

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

Neden bazı projeler \strlen() kullanır?

Bunun birkaç sebebi var.

1. Açık niyet

\strlen($value);

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

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

Bu özellikle framework, SDK veya package geliştirirken güzel bir sinyaldir.

Mesela:

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.

2. Namespace içinde aynı isimli 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.

3. Ç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);

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 \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 üstte açıkça belirtilmiş olur.

Ama pratikte çoğu PHP/Laravel projesinde bu kadar detaylı import kullanılmaz. Daha çok package veya library seviyesinde karşımıza çıkar.

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ğilsin:

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

Benim pratik önerim şu olur:

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ış işe yarayabilir

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('a', $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.