Constantes de clase en PHP OOP

Una constante de clase es un valor fijo con nombre que pertenece a una clase y no a ningún objeto en particular. Se define una sola vez, nunca puede reasignarse en tiempo de ejecución y es compartida por todas las instancias de la clase. Las constantes son la manera de dar nombres significativos a los valores "mágicos" de los que depende tu código — una tasa impositiva, una cadena de estado, una versión de API — de modo que vivan en un único lugar en lugar de estar dispersos como literales.

Este capítulo cubre cómo declarar constantes de clase con const, cómo leerlas con self, static y el nombre de la clase, cómo controlar su visibilidad y cómo se comportan con la herencia y las interfaces. Todos los ejemplos a continuación funcionan en PHP 8.

¿Por qué usar constantes de clase?

Recurre a una constante de clase cuando un valor es conocido de antemano y nunca debe cambiar mientras se ejecuta el script:

• Fuente única de verdad. Define un valor como Order::SHIPPING_FEE una vez; cada llamador lee el mismo número.
• Legibilidad. Circle::PI dice mucho más que un simple 3.14159 enterrado en un cálculo.
• Seguridad. PHP rechaza cualquier intento de reasignar una constante, por lo que un error tipográfico no puede sobrescribirla silenciosamente.
• Sin necesidad de objeto. Como una constante pertenece a la clase, puedes leerla sin crear una instancia.

Las constantes de clase difieren de las variables regulares de dos maneras importantes: se escriben sin signo de dólar (MAX_USERS, no $MAX_USERS), y son inmutables una vez definidas.

Definir una constante de clase

Declara una constante dentro del cuerpo de la clase con la palabra clave const, un nombre (convencionalmente UPPER_SNAKE_CASE) y un valor:

<?php

class MyClass {
    const CONSTANT = 'constant value';

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

Esto define CONSTANT en MyClass. Una constante de clase no es lo mismo que una constante global creada con define(): const pertenece a la clase y se accede mediante ::, mientras que define() registra un nombre en el ámbito global.

El valor puede ser una expresión constante — un cálculo que PHP puede resolver en tiempo de compilación — e incluso un array:

<?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

Lo que no puedes usar es nada que solo se conozca en tiempo de ejecución — las llamadas a funciones, las instancias de objetos o las $variables no están permitidas en el valor de una constante.

Acceder a una constante de clase

La forma de leer una constante depende de dónde estés:

• Desde fuera de la clase, usa el nombre de la clase: MyClass::CONSTANT.
• Desde dentro de la clase, usa la palabra clave self: self::CONSTANT.

constant value
constant value

La primera línea lee la constante de forma estática a través del nombre de la clase — sin necesidad de objeto. La segunda lo hace a través de un método de instancia que usa self::CONSTANT. Ten en cuenta que se accede a las constantes con ::, nunca con el operador de objeto -> que se usa para las propiedades.

Controlar la visibilidad

Desde PHP 7.1, las constantes de clase aceptan los mismos modificadores de visibilidad que las propiedades y los métodos: public (el valor predeterminado), protected y private. Esto permite ocultar los detalles de implementación que pertenecen a la clase pero que no deben leerse desde fuera.

<?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

Aquí Config::VERSION es accesible en cualquier lugar, mientras que API_KEY y SALT solo pueden ser leídas desde dentro de la clase (o, en el caso de protected, desde sus subclases). Intentar leer Config::SALT desde fuera genera un error.

Constantes y herencia

Las subclases heredan las constantes de su clase padre y pueden sobrescribirlas. La palabra clave que usas para leer la constante determina qué versión obtienes:

• self::NAME se resuelve cuando se escribe el código — siempre hace referencia a la constante en la clase donde está definido el método.
• static::NAME se resuelve en tiempo de ejecución según la clase que fue llamada. Esto se denomina enlace estático tardío (late static binding).

<?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

Las interfaces también pueden declarar constantes; son implícitamente public y son compartidas por todas las clases que las implementan. Si necesitas una constante que las subclases no puedan sobrescribir, márcala como final (PHP 8.1+): final const ID = 100;. PHP 8.3 también añadió constantes tipadas, por ejemplo: const string LABEL = 'base';.

Para más información sobre el comportamiento de las subclases, consulta PHP Inheritance y, para la función de datos a nivel de clase relacionada, PHP Static Properties.

Errores comunes

• Sin signo de dólar. const RATE = 0.2; — escribir $RATE es un error de sintaxis.
• ::, no ->. Las constantes siempre se acceden con el operador de resolución de ámbito.
• Los valores en tiempo de ejecución son rechazados. El valor de una constante debe ser una expresión constante; const NOW = time(); no compilará.
• self vs static. Usa static:: cuando quieras que una subclase pueda sobrescribir el valor; de lo contrario, self:: es la opción más segura y predecible.

Conclusión

Las constantes de clase te ofrecen valores con nombre, inmutables y de ámbito de clase, definidos con const y leídos mediante ::. Úsalas para centralizar valores fijos, mejorar la legibilidad y bloquear datos que nunca deben cambiar en tiempo de ejecución. Combínalas con modificadores de visibilidad para ocultar detalles internos, y recuerda la distinción entre self y static una vez que la herencia entra en juego.

Práctica