POO Leccion 36 de 75 8 min de lectura

Constantes de Clase

Las constantes de clase son valores inmutables definidos en una clase. Son utiles para valores fijos que no deben cambiar durante la ejecucion.

Definir constantes de clase

Las constantes se definen con const y por convencion se escriben en MAYUSCULAS:

PHP 
<?php
declare(strict_types=1);

class Circulo
{
    public const PI = 3.14159265359;

    private float $radio;

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

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

// Acceso desde fuera de la clase
echo Circulo::PI; // 3.14159265359

$circulo = new Circulo(5);
echo $circulo->getArea(); // 78.54...

Visibilidad de constantes

Las constantes pueden tener visibilidad como propiedades y metodos:

PHP 
<?php
declare(strict_types=1);

class Database
{
    public const DRIVER_MYSQL = 'mysql';
    public const DRIVER_PGSQL = 'pgsql';

    protected const TIMEOUT = 30;
    private const MAX_RETRIES = 3;

    public function conectar(): void
    {
        // Acceso a todas las constantes dentro de la clase
        echo self::DRIVER_MYSQL;
        echo self::TIMEOUT;
        echo self::MAX_RETRIES;
    }
}

echo Database::DRIVER_MYSQL;  // mysql
echo Database::DRIVER_PGSQL;  // pgsql
// echo Database::TIMEOUT;    // Error: protected
// echo Database::MAX_RETRIES; // Error: private

Constantes como opciones

Un uso comun es definir opciones o estados posibles:

PHP 
<?php
declare(strict_types=1);

class Pedido
{
    public const ESTADO_PENDIENTE = 'pendiente';
    public const ESTADO_PROCESANDO = 'procesando';
    public const ESTADO_ENVIADO = 'enviado';
    public const ESTADO_ENTREGADO = 'entregado';
    public const ESTADO_CANCELADO = 'cancelado';

    private string $id;
    private string $estado;

    public function __construct(string $id)
    {
        $this->id = $id;
        $this->estado = self::ESTADO_PENDIENTE;
    }

    public function procesar(): void
    {
        $this->estado = self::ESTADO_PROCESANDO;
    }

    public function enviar(): void
    {
        $this->estado = self::ESTADO_ENVIADO;
    }

    public function getEstado(): string
    {
        return $this->estado;
    }
}

$pedido = new Pedido('P001');
echo $pedido->getEstado(); // pendiente

$pedido->procesar();
echo $pedido->getEstado(); // procesando

// Comparar estados
if ($pedido->getEstado() === Pedido::ESTADO_PROCESANDO) {
    echo 'El pedido esta en proceso';
}
Constantes vs Enums

Para conjuntos de valores relacionados, PHP 8.1 introdujo enums, que son una alternativa mas robusta. Los veremos en el modulo de PHP 8.x.

Constantes en interfaces

Las interfaces tambien pueden definir constantes:

PHP 
<?php
declare(strict_types=1);

interface CodigosHTTP
{
    public const OK = 200;
    public const CREATED = 201;
    public const BAD_REQUEST = 400;
    public const UNAUTHORIZED = 401;
    public const NOT_FOUND = 404;
    public const SERVER_ERROR = 500;
}

class Respuesta implements CodigosHTTP
{
    private int $codigo;
    private string $mensaje;

    public function __construct(int $codigo, string $mensaje)
    {
        $this->codigo = $codigo;
        $this->mensaje = $mensaje;
    }

    public static function ok(string $mensaje): self
    {
        return new self(self::OK, $mensaje);
    }

    public static function notFound(string $mensaje): self
    {
        return new self(self::NOT_FOUND, $mensaje);
    }
}

$respuesta = Respuesta::ok('Operacion exitosa');
$error = Respuesta::notFound('Recurso no encontrado');

Ejemplo practico: Configuracion de aplicacion

PHP 
<?php
declare(strict_types=1);

class App
{
    public const VERSION = '1.0.0';
    public const NOMBRE = 'Mi Aplicacion';

    public const ENTORNO_DEV = 'development';
    public const ENTORNO_PROD = 'production';

    private const LIMITE_SUBIDA = 10485760; // 10MB en bytes

    public static function getLimiteSubida(): int
    {
        return self::LIMITE_SUBIDA;
    }

    public static function getLimiteSubidaMB(): float
    {
        return self::LIMITE_SUBIDA / 1024 / 1024;
    }
}

echo App::NOMBRE . ' v' . App::VERSION; // Mi Aplicacion v1.0.0
echo App::getLimiteSubidaMB() . ' MB';  // 10 MB

Ejercicios

Ejercicio 1: Clase Tiempo

Crea una clase Tiempo con constantes para SEGUNDOS_MINUTO, SEGUNDOS_HORA y SEGUNDOS_DIA. Agrega metodos estaticos para convertir entre unidades.

Ver solucion
PHP 
<?php
declare(strict_types=1);

class Tiempo
{
    public const SEGUNDOS_MINUTO = 60;
    public const SEGUNDOS_HORA = 3600;
    public const SEGUNDOS_DIA = 86400;

    public static function minutosASegundos(int $minutos): int
    {
        return $minutos * self::SEGUNDOS_MINUTO;
    }

    public static function horasASegundos(int $horas): int
    {
        return $horas * self::SEGUNDOS_HORA;
    }

    public static function diasASegundos(int $dias): int
    {
        return $dias * self::SEGUNDOS_DIA;
    }

    public static function segundosAHoras(int $segundos): float
    {
        return $segundos / self::SEGUNDOS_HORA;
    }
}

echo Tiempo::minutosASegundos(5);  // 300
echo Tiempo::horasASegundos(2);    // 7200
echo Tiempo::segundosAHoras(7200); // 2

Ejercicio 2: Roles de usuario

Crea una clase Usuario con constantes para roles (ROL_ADMIN, ROL_EDITOR, ROL_USUARIO) y un metodo tienePermiso(string $permiso): bool.

Ver solucion
PHP 
<?php
declare(strict_types=1);

class Usuario
{
    public const ROL_ADMIN = 'admin';
    public const ROL_EDITOR = 'editor';
    public const ROL_USUARIO = 'usuario';

    private const PERMISOS = [
        self::ROL_ADMIN => ['crear', 'editar', 'borrar', 'ver', 'admin'],
        self::ROL_EDITOR => ['crear', 'editar', 'ver'],
        self::ROL_USUARIO => ['ver'],
    ];

    private string $nombre;
    private string $rol;

    public function __construct(string $nombre, string $rol = self::ROL_USUARIO)
    {
        $this->nombre = $nombre;
        $this->rol = $rol;
    }

    public function tienePermiso(string $permiso): bool
    {
        $permisos = self::PERMISOS[$this->rol] ?? [];
        return in_array($permiso, $permisos, true);
    }

    public function getRol(): string
    {
        return $this->rol;
    }
}

$admin = new Usuario('Ana', Usuario::ROL_ADMIN);
$usuario = new Usuario('Luis', Usuario::ROL_USUARIO);

var_dump($admin->tienePermiso('borrar'));   // true
var_dump($usuario->tienePermiso('borrar')); // false
var_dump($usuario->tienePermiso('ver'));    // true

Ejercicio 3: Validador con limites

Crea una clase Validador con constantes para limites (MAX_NOMBRE, MIN_PASSWORD, etc.) y metodos que usen esas constantes para validar.

Ver solucion
PHP 
<?php
declare(strict_types=1);

class Validador
{
    public const MIN_NOMBRE = 2;
    public const MAX_NOMBRE = 50;
    public const MIN_PASSWORD = 8;
    public const MAX_PASSWORD = 100;
    public const MIN_EDAD = 18;
    public const MAX_EDAD = 120;

    public static function validarNombre(string $nombre): bool
    {
        $len = strlen($nombre);
        return $len >= self::MIN_NOMBRE && $len <= self::MAX_NOMBRE;
    }

    public static function validarPassword(string $password): bool
    {
        $len = strlen($password);
        return $len >= self::MIN_PASSWORD && $len <= self::MAX_PASSWORD;
    }

    public static function validarEdad(int $edad): bool
    {
        return $edad >= self::MIN_EDAD && $edad <= self::MAX_EDAD;
    }

    public static function getMensajeError(string $campo): string
    {
        $mensajes = [
            'nombre' => 'Nombre debe tener entre ' . self::MIN_NOMBRE . ' y ' . self::MAX_NOMBRE . ' caracteres',
            'password' => 'Password debe tener minimo ' . self::MIN_PASSWORD . ' caracteres',
            'edad' => 'Edad debe estar entre ' . self::MIN_EDAD . ' y ' . self::MAX_EDAD,
        ];
        return $mensajes[$campo] ?? 'Campo invalido';
    }
}

var_dump(Validador::validarNombre('A'));           // false
var_dump(Validador::validarNombre('Ana Garcia'));  // true
var_dump(Validador::validarPassword('123'));       // false
var_dump(Validador::validarEdad(25));              // true

¿Te está gustando el curso?

Tenemos cursos premium con proyectos reales y soporte personalizado.

Descubrir cursos premium