Mi a késleltetett statikus kötés PHP-ben?

Ez a mechanizmus lehetővé teszi, hogy a statikus hívások kontextusában hivatkozzunk a hívott osztályra. Megoldja az önreferenciák problémáját az öröklődő osztályokban, amikor a static:: kulcsszót használjuk.

Nézzünk egy példát a self:: használatával:

<?php
class A {
    public static function who() {
        echo __CLASS__; // A-t ír ki
    }
    public static function test() {
        self::who(); // A::who() hívását eredményezi
    }
}
class B extends A {
    public static function who() {
        echo __CLASS__; // B-t ír ki
    }
}

B::test(); // A-t ír ki

Ebben az esetben a self::who() az A osztályon belül mindig az A osztály who metódusát hívja meg, akkor is, ha a test() hívás a B osztályból történik.

Most nézzük a static:: használatával készült példát:

<?php
class A {
    public static function who() {
        echo __CLASS__;
    }
    public static function test() {
        static::who(); // Azt az osztályt hívja meg, amelyik a `test()` hívását indította
    }
}
class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test(); // B-t ír ki

Itt a static::who() az A osztályon belül, amikor a B osztályból hívják meg, a B osztályra fog hivatkozni, és a B osztály who() metódusát hívja meg.

A késleltetett statikus kötés lehetővé teszi, hogy dinamikusan határozzuk meg, melyik osztályt használjuk egy statikus hívás kontextusában, attól függően, hogy melyik osztályt hívták meg valójában. Ez különösen hasznos hierarchiákban és olyan statikus metódusok esetén, amelyek polimorf módon kell viselkedjenek. A működés azzal az emlékezéssel működik, hogy a "nem-átirányított hívott osztályt" (az utolsó osztályt a öröklési láncban, ahonnan a statikus hívás kezdődött) megjegyzi, és ezt használja a static:: hivatkozások feloldásához.