const

La palabra clave const de PHP

Una constante es un valor con nombre que no puede cambiar mientras se ejecuta un script. La palabra clave const es una de las dos formas que PHP ofrece para declarar una constante (la otra es la función define()). A diferencia de una variable, una constante no lleva $ al inicio, y una vez definida no se puede reasignar ni aplicarle unset().

Esta guía explica qué hace const, en qué se diferencia de define(), dónde puedes usarla y los errores comunes que suelen surgir.

Sintaxis

Puedes usar const en el nivel superior de un script (una constante global) o dentro de una clase, interfaz o trait (una constante de clase):

const NAME = value;          // global constant

class ClassName {
  const NAME = value;        // class constant, accessed as ClassName::NAME
}

Por convención, los nombres de las constantes se escriben en UPPER_SNAKE_CASE. Un nombre debe comenzar con una letra o guion bajo y solo puede contener letras, dígitos y guiones bajos.

const vs define()

PHP ofrece dos herramientas que parecen similares pero se comportan de manera distinta. Conocer las diferencias ahorra tiempo de depuración:

Como regla general: usa const para valores fijos y siempre definidos (especialmente constantes de clase), y define() cuando el nombre o el valor se determina mientras el programa se ejecuta.

<?php
// define() can be conditional; const cannot.
if (!defined('ENVIRONMENT')) {
  define('ENVIRONMENT', 'production');
}

// This would be a fatal parse error — const cannot live inside an if-block:
// if (true) { const FOO = 1; }

Consulta el capítulo dedicado a define() y la descripción general de constantes PHP para más información.

Ejemplos

Constante de clase y constante global

<?php

// Example 1 — a class constant referenced with self::
class Circle
{
  const PI = 3.14;
  public $radius;

  public function __construct($radius)
  {
    $this->radius = $radius;
  }

  public function getArea()
  {
    return self::PI * $this->radius * $this->radius;
  }
}

$myCircle = new Circle(5);
echo "Area of circle: " . $myCircle->getArea() . PHP_EOL;

// Output: Area of circle: 78.5

// Example 2 — a global constant
const MY_NAME = "John";
echo "My name is " . MY_NAME;

// Output: My name is John

Se accede a una constante de clase con el operador :: (resolución de ámbito): self::PI desde dentro de la clase, Circle::PI desde fuera. Una constante global se usa por su nombre sin $. Para más información sobre clases, consulta clases y objetos de PHP y el capítulo de constantes de clase.

Expresiones constantes y arrays

El valor de const debe ser una expresión constante — algo que PHP pueda evaluar sin ejecutar código. Puedes usar literales, operadores y otras constantes ya definidas, y (desde PHP 5.6) el resultado puede ser un array.

<?php
const SECONDS_PER_MINUTE = 60;
const SECONDS_PER_HOUR   = SECONDS_PER_MINUTE * 60;  // built from another const
const ALLOWED_ROLES      = ['admin', 'editor', 'viewer'];

echo SECONDS_PER_HOUR . PHP_EOL;       // 3600
echo ALLOWED_ROLES[1] . PHP_EOL;       // editor

Las llamadas a funciones y las instancias de objetos no están permitidas en el valor de const porque no se pueden resolver en tiempo de compilación.

Constantes de clase: visibilidad, interfaces y final

Las constantes de clase pertenecen a la clase, no a ningún objeto en particular, por lo que no necesitas una instancia para acceder a ellas. Desde PHP 7.1 también puedes asignarles un modificador de visibilidad:

<?php
interface HasStatus
{
  // Interface constants are always public.
  const DEFAULT_STATUS = 'pending';
}

class Order implements HasStatus
{
  public const TAX_RATE   = 0.2;   // readable everywhere
  protected const MAX_QTY = 99;    // this class + subclasses
  private const SECRET    = 'x';   // this class only

  public function status(): string
  {
    return self::DEFAULT_STATUS;   // inherited from the interface
  }
}

echo Order::TAX_RATE . PHP_EOL;        // 0.2
echo (new Order())->status() . PHP_EOL; // pending

Las interfaces también pueden declarar constantes (siempre públicas) — consulta interfaces de PHP. Una constante de clase puede marcarse como final (PHP 8.1+) para evitar que las subclases la sobreescriban.

Errores comunes

• Sin $ en una constante. echo MY_NAME; funciona; echo $MY_NAME; busca una variable y falla.
• No se puede cambiar ni eliminar. Reasignar una constante es un error fatal; unset() no funciona con constantes.
• Solo en tiempo de compilación. No puedes envolver const en un if, bucle o función basada en datos de ejecución — usa define() para eso.
• Las constantes son de ámbito global. Una const global es visible dentro de las funciones sin necesidad de global, a diferencia de una variable normal.

Beneficios

• Legibilidad: una constante con nombre como TAX_RATE documenta la intención mucho mejor que un número mágico.
• Mantenibilidad: cambia el valor en un solo lugar en lugar de buscar cada literal.
• Seguridad: el valor es de solo lectura, por lo que no puede sobrescribirse accidentalmente en ninguna parte del código.

Conclusión

La palabra clave const define constantes en tiempo de compilación — tanto globales como dentro de clases — que permanecen fijas durante toda la vida de un script. Úsala para valores fijos que siempre conoces de antemano, prefiere las constantes de clase para valores que pertenecen a un tipo, y cambia a define() cuando necesites crear una constante condicionalmente o con un nombre dinámico. Para profundizar más, continúa con los capítulos de constantes PHP y constantes de clase.

Práctica