Late Static Binding in PHP allows static:: to refer to the class initially called at runtime in inheritance scenarios. Before PHP 5.3, self:: always referenced the class where the method was defined, causing ChildClass::sayHello() to output "ParentClass". With late static binding, replacing self:: with static:: ensures correct resolution to the invoked class, making ChildClass::sayHello() output "ChildClass". It is useful when child classes need to override static methods or properties, such as in ORM models where each subclass defines its own $table. Key points: 1. Use static:: instead of self:: for dynamic resolution; 2. Applies only to static contexts; 3. Requires PHP 5.3 or later; 4. Avoid confusion with self:: and parent::.

Late Static Binding in PHP is a feature that allows you to reference the class that was originally called in the context of inheritance, rather than the class where the method is defined. This might sound abstract at first, but it's actually pretty useful when working with static methods and properties across parent and child classes.

Without late static binding, PHP would always resolve static calls to the class where the method is defined — not necessarily the one that was called. Late static binding fixes this by letting static:: refer to the class that was invoked at runtime.

Let’s break down how it works and when you’d use it.

How Late Static Binding Works

In PHP, before late static binding was introduced (in PHP 5.3), calling a static method from a parent class would always use the parent's context. For example:

class ParentClass {
    public static function whoAmI() {
        echo __CLASS__;
    }

    public static function sayHello() {
        self::whoAmI();
    }
}

class ChildClass extends ParentClass {
    public static function whoAmI() {
        echo __CLASS__;
    }
}

ChildClass::sayHello(); // Outputs: ParentClass

Here, even though we're calling sayHello() on ChildClass, it outputs "ParentClass" because self:: refers to the class where the method is defined.

With late static binding, you can change this behavior using static:: instead of self::. Let's adjust the code:

class ParentClass {
    public static function whoAmI() {
        echo __CLASS__;
    }

    public static function sayHello() {
        static::whoAmI();
    }
}

class ChildClass extends ParentClass {
    public static function whoAmI() {
        echo __CLASS__;
    }
}

ChildClass::sayHello(); // Outputs: ChildClass

Now it correctly outputs "ChildClass", because static:: refers to the class that was initially called at runtime.

When to Use Late Static Binding

You should consider using late static binding when:

• You're working with inheritance and want child classes to override static methods.
• You need to access static properties or methods in a way that respects the actual class being called.
• You're building reusable base classes (like abstract factories or utility classes) that are meant to be extended.

A common use case is when you have a base model class in an ORM setup. For example:

class Model {
    protected static $table;

    public static function getTable() {
        return static::$table;
    }
}

class User extends Model {
    protected static $table = 'users';
}

echo User::getTable(); // Outputs: users

This way, each child class can define its own table name without having to override the getTable() method.

Common Pitfalls to Avoid

There are a few gotchas to watch out for when using late static binding:

• It only works with static::, not self:: – If you use self::, it will still refer to the defining class, not the runtime class.
• Static context vs. instance context – Late static binding applies only to static method and property calls. If you're inside an object instance, $this already knows which class it belongs to.
• Compatibility with older PHP versions – Make sure your environment supports PHP 5.3 or later if you plan to use this feature.

Also, don’t confuse static:: with parent:: or self::. Each has its own purpose:

• self:: always points to the current class where it's written.
• parent:: is used to call methods from the parent class.
• static:: dynamically refers to the class called at runtime.

So, late static binding gives you more flexibility when dealing with inheritance in static contexts. It's especially handy when designing extensible class hierarchies. Just remember to use static:: instead of self:: when you want to respect the actual class that was called.

That’s basically it — not too complicated once you see it in action, but super useful in the right scenarios.

The above is the detailed content of What is Late Static Binding in PHP?. For more information, please follow other related articles on the PHP Chinese website!