Comprendre les constantes OOP en PHP

Une constante de classe est une valeur fixe et nommée qui appartient à une classe plutôt qu'à un objet particulier. Elle est définie une seule fois, ne peut jamais être réassignée à l'exécution, et est partagée par toutes les instances de la classe. Les constantes permettent de donner des noms significatifs aux valeurs « magiques » dont dépend votre code — un taux de taxe, une chaîne de statut, une version d'API — afin qu'elles se trouvent en un seul endroit plutôt que d'être dispersées sous forme de littéraux.

Ce chapitre explique comment déclarer des constantes de classe avec const, comment les lire avec self, static et le nom de classe, comment contrôler leur visibilité, et comment elles se comportent avec l'héritage et les interfaces. Tous les exemples ci-dessous s'exécutent avec PHP 8.

Pourquoi utiliser des constantes de classe ?

Optez pour une constante de classe quand une valeur est connue à l'avance et ne doit jamais changer pendant l'exécution du script :

• Source unique de vérité. Définissez une valeur telle que Order::SHIPPING_FEE une fois ; chaque appelant lit le même nombre.
• Lisibilité. Circle::PI est bien plus parlant qu'un 3.14159 nu enfoui dans un calcul.
• Sécurité. PHP rejette toute tentative de réassignation d'une constante, donc une faute de frappe ne peut pas l'écraser silencieusement.
• Aucun objet nécessaire. Comme une constante appartient à la classe, vous pouvez la lire sans créer d'instance.

Les constantes de classe se distinguent des variables ordinaires de deux façons importantes : elles s'écrivent sans signe dollar (MAX_USERS, et non $MAX_USERS), et elles sont immuables une fois définies.

Définir une constante de classe

Déclarez une constante dans le corps de la classe avec le mot-clé const, un nom (par convention en UPPER_SNAKE_CASE) et une valeur :

<?php

class MyClass {
    const CONSTANT = 'constant value';

    public function showConstant() {
        echo self::CONSTANT . "\n";
    }
}

Cela définit CONSTANT sur MyClass. Une constante de classe n'est pas la même chose qu'une constante globale créée avec define() : const appartient à la classe et est accessible via ::, tandis que define() enregistre un nom dans la portée globale.

La valeur peut être une expression constante — un calcul que PHP peut résoudre à la compilation — et même un tableau :

<?php

class Circle {
    const PI = 3.14159;
    const TWO_PI = self::PI * 2; // built from another constant
    const UNITS = ['mm', 'cm', 'm'];
}

echo Circle::TWO_PI . "\n";   // 6.28318
echo Circle::UNITS[1] . "\n"; // cm

Ce que vous ne pouvez pas utiliser, c'est ce qui n'est connu qu'à l'exécution — les appels de fonctions, les instances d'objets ou les $variables ne sont pas autorisés dans la valeur d'une constante.

Accéder à une constante de classe

La façon dont vous lisez une constante dépend de l'endroit où vous vous trouvez :

• Depuis l'extérieur de la classe, utilisez le nom de la classe : MyClass::CONSTANT.
• Depuis l'intérieur de la classe, utilisez le mot-clé self : self::CONSTANT.

constant value
constant value

La première ligne lit la constante de manière statique via le nom de classe — aucun objet n'est nécessaire. La seconde passe par une méthode d'instance qui utilise self::CONSTANT. Notez que vous accédez aux constantes avec ::, jamais avec l'opérateur d'objet -> que vous utilisez pour les propriétés.

Contrôler la visibilité

Depuis PHP 7.1, les constantes de classe acceptent les mêmes modificateurs de visibilité que les propriétés et méthodes : public (par défaut), protected et private. Cela vous permet de masquer les détails d'implémentation qui appartiennent à la classe mais ne devraient pas être lus depuis l'extérieur.

<?php

class Config {
    public const VERSION = '2.0';
    protected const API_KEY = 'secret-123';
    private const SALT = 'x9f2';

    public function describe(): string {
        return self::VERSION . ' / ' . self::API_KEY . ' / ' . self::SALT;
    }
}

echo Config::VERSION . "\n"; // 2.0 — public, readable anywhere
$c = new Config();
echo $c->describe() . "\n";  // 2.0 / secret-123 / x9f2

Ici Config::VERSION est accessible partout, tandis que API_KEY et SALT ne peuvent être atteints que depuis l'intérieur de la classe (ou, pour protected, ses sous-classes). Tenter de lire Config::SALT depuis l'extérieur provoque une erreur.

Constantes et héritage

Les sous-classes héritent des constantes de leur parent et peuvent les remplacer. Le mot-clé que vous utilisez pour lire la constante détermine quelle version vous obtenez :

• self::NAME est résolu à l'écriture du code — il désigne toujours la constante dans la classe où la méthode est définie.
• static::NAME est résolu à l'exécution par rapport à la classe réellement appelée. C'est ce qu'on appelle la liaison statique tardive.

<?php

interface HasStatus {
    const ACTIVE = 'active'; // interface constants are always public
}

class Order implements HasStatus {
    const SHIPPING_FEE = 5.00;

    public function status(): string {
        return self::ACTIVE;
    }
}

class ExpressOrder extends Order {
    const SHIPPING_FEE = 15.00;

    public function fee(): float {
        return static::SHIPPING_FEE; // uses the called class's value
    }
}

echo Order::ACTIVE . "\n";              // active (inherited from the interface)
echo (new ExpressOrder())->fee() . "\n";    // 15
echo (new ExpressOrder())->status() . "\n"; // active

Les interfaces peuvent également déclarer des constantes ; elles sont implicitement public et partagées par chaque classe qui les implémente. Si vous avez besoin d'une constante que les sous-classes ne doivent pas remplacer, marquez-la final (PHP 8.1+) : final const ID = 100;. PHP 8.3 a également ajouté les constantes typées, par ex. const string LABEL = 'base';.

Pour en savoir plus sur le comportement des sous-classes, consultez PHP Inheritance, et pour la fonctionnalité connexe des données au niveau de la classe, PHP Static Properties.

Pièges courants

• Pas de signe dollar. const RATE = 0.2; — écrire $RATE est une erreur de syntaxe.
• ::, pas ->. Les constantes sont toujours accessibles avec l'opérateur de résolution de portée.
• Les valeurs d'exécution sont rejetées. La valeur d'une constante doit être une expression constante ; const NOW = time(); ne compilera pas.
• self vs static. Utilisez static:: lorsque vous souhaitez qu'une sous-classe puisse remplacer la valeur ; sinon self:: est le choix plus sûr et plus prévisible.

Conclusion

Les constantes de classe vous donnent des valeurs nommées, immuables et limitées à la portée de la classe, définies avec const et lues via ::. Utilisez-les pour centraliser les valeurs fixes, améliorer la lisibilité et verrouiller les données qui ne doivent jamais changer à l'exécution. Combinez-les avec les modificateurs de visibilité pour masquer les détails internes, et souvenez-vous de la distinction entre self et static dès que l'héritage entre en jeu.

Pratique