2026.06.23.
Kódolás, keretrendszerek

Clean kód php strict types használatával

Temesvári László

A PHP 8 típusosság és a strict_types használata valódi projektekben

Bevezetés

A PHP fejlődése során egyre inkább a robusztus, karbantartható kód felé mozdult el. A PHP 8 jelentős lépést tett ebben az irányban, erőteljesebb típusrendszerrel és opcionális, de erősen ajánlott szigorú típusellenőrzéssel. A strict_types használata nem csupán egy nyelvi jellemző, hanem alapvető clean code elv, amely jelentősen csökkenti a hibák számát és növeli a kód olvashatóságát. Ebben a cikkben megvizsgáljuk, hogyan integrálható hatékonyan a szigorú típusosság mindennapi PHP projektjeinkbe.

Mi a strict_types?

A declare(strict_types=1); direktíva a fájl elején mondja ki, hogy a fájlban a függvények és metódusok paraméterei és visszatérési értékei szigorú típusellenőrzés alá esnek. Enélkül a PHP típuskényszerítést hajt végre, ami gyakran váratlan eredményekhez vezethet.

 15 (implicit konverzió)
// Szigorú módban: TypeError!

Gyakorlati előnyök valódi projektekben

1. Korai hibadetekció

A szigorú típusok a fejlesztési időszakban, legkésőbb teszteléskor felderítik a típushibákat, nem éles környezetben futás közben. Egy API végpont például azonnal hibát jelez, ha helytelen típusú adatot kap, nem próbálja „kitalálni” a fejlesztő szándékát.

2. Öndokumentáló kód

A típusdeklarációk egyértelművé teszik, hogy egy függvény mit vár el és mit ad vissza. Ez különösen értékes nagyobb csapatokban vagy régebbi kód alapján dolgozva. 
<?php
declare(strict_types=1);

class OrderService {
    public function calculateTotal(
        Cart $cart,
        User $user,
        bool $includeVat = true
    ): float {
        // A paraméterek és visszatérés típusa egyértelmű
        // Nem kell találgatni, hogy a Cart lehet-e tömb vagy objektum
    }
}

3. Könnyebb refaktorálás és karbantartás

Amikor módosítjuk egy metódus szignatúráját, a típusrendszer figyelmeztet, ha egy hívó hely nem megfelelő paramétert ad át. Ez megbízhatóbbá teszi a nagyobb átalakításokat.

Közös kihívások és megoldások

1. Külső könyvtárak és legacy kód

Nem minden külső függőség használ szigorú típusokat. Ilyenkor a saját kódunk és a külső kód határán érdemes típusellenőrzést végezni. 
<?php
declare(strict_types=1);

class ExternalServiceAdapter {
    public function processData(array $legacyData): UserDTO {
        // Itt ellenőrizzük és alakítjuk át a legacy adatokat
        $id = (int)$legacyData['id'];
        $name = (string)$legacyData['name'];
        
        return new UserDTO($id, $name);
    }
}

2. Adatbázisból származó értékek

Az adatbázis lekérdezések eredményei gyakran sztringek, még ha szám oszlopról is van szó. Ezt explicit kezelni kell. 
db->query("SELECT * FROM users WHERE id = ?", [$id]);
        
        if ($row = $result->fetch()) {
            // Explicit konverzió adatbázis értékekre
            return new User(
                (int)$row['id'],
                (string)$row['name'],
                (string)$row['email']
            );
        }
        
        return null;
    }
}

3. Tömbök és gyűjtemények

A PHP 8-ban még nem létezik generikus típus, de a tömbök strukturált adatait jelölhetjük PHPDoc kommentekkel, amelyet sok IDE és statikus elemző (például PHPStan) felhasznál. 
<?php
declare(strict_types=1);

/**
 * @param array $users
 * @return array
 */
public function getUserNames(array $users): array {
    return array_map(fn(User $user) => $user->getName(), $users);
}

Ajánlott bevezetési stratégia

1. Fokozatosan vezessük be, fájlonként aktiválva a strict_types-t 2. Kezdjük az új fájlokkal és a legkritikusabb modulokkal 3. Használjunk statikus elemzőt (PHPStan, Psalm) a típusproblémák azonosítására 4. Dokumentáljuk a csapat számára a változásokat és előnyöket 5. Integráljuk a CI/CD folyamatba a típusellenőrzést

Gyakori hibák és tanulságok

– Elfelejtett declare: A strict_types csak az adott fájlra vonatkozik, ahol deklarálva van – Túl korai visszatérési típus: Ne használj mixed-et, csak ha abszolút szükséges – Interface-k következetessége: Az implementációk típusai pontosabban deklarálhatók, de nem eltérően az interfésztől – Nullable típusok: Használjunk ?Type jelölést, ha egy érték lehet null

<?php
declare(strict_types=1);

// Rossz példa - típus információ hiánya
function process($data) {
    // Mi a $data típusa? Mi a visszatérés?
}

// Jó példa - teljes típusinformáció
function process(UserDTO $data): ProcessResult {
    // Tiszta, karbantartható kód
}

Összegzés

A PHP 8 típusrendszere és a strict_types használata nem csupán technikai kérdés, hanem minőségi váltás a clean code irányába. Valódi projektekben: – Csökkenti a futásidejű hibák számát – Javítja a kód öndokumentáló képességét – Megkönnyíti a csapatmunka és karbantartást – Integráltan működik modern fejlesztői eszközökkel

A kezdeti beruházás a típusok hozzáadásába és a szigorú mód bekapcsolásába hosszú távon többszörösen megtérül a robusztusabb, kiszámíthatóbb és könnyebben karbantartható kódbázis formájában. A modern PHP fejlesztés alapvető eszköze, amelyet minden új projektben érdemes alapvető követelményként kezelni.

A weboldalon megjelenő szöveges és vizuális tartalmak előállításához mesterséges intelligenciát (AI) használunk.

Kapcsolódó cikkek