POO en PHP: clases, interfaces, enums y PHP 8.5
Clases readonly, traits, static vs self, enums, property hooks y el pipe de 8.5 en PHP 8.5.6: errores reales y memoria medida (17.5 MB vs 41.7 MB).
Serie: curso de PHP 3/6 (intermedio). Esta clase es para quien ya escribe funciones en PHP y maneja un formulario, y ahora quiere ordenar el código con clases: el freelancer que heredó un sistema de turnos o de facturación lleno de arrays sueltos, la persona que entró a una startup con un backend en Laravel y no entiende qué hace static, o el estudiante cuyo curso de la universidad pide "aplicar POO" en el proyecto final. Al terminar vas a saber qué construcción elegir (clase, interfaz, clase abstracta, trait o enum) y qué error lanza PHP 8.5 cuando te equivocas.
Si aprendiste PHP con tutoriales viejos, tus clases probablemente tienen un constructor que copia cinco argumentos en cinco propiedades, constantes string para los estados y un getX() por cada campo. Ese código sigue funcionando, pero deja pasar bugs que el PHP moderno frena en la primera línea. Aquí lo reconstruimos con funciones de PHP 8.x, ejecutamos cada ejemplo en PHP 8.5.6 CLI (Mac con Apple Silicon, M1 Pro, OPcache apagado salvo que se diga lo contrario) y mostramos el error exacto que produce cada equivocación.
¿Vienes de Java o C#? La mayoría de los conceptos se corresponden de forma directa; mira nuestra clase de Java: clases, records e interfaces para comparar. Las trampas propias de PHP son los traits, static y los enums que no se serializan.
Clases, promoción en el constructor y readonly
La promoción de propiedades en el constructor (constructor property promotion, PHP 8.0) declara y asigna una propiedad directamente en la firma del constructor. readonly (8.1) permite exactamente una asignación, desde dentro de la clase.
<?php
declare(strict_types=1);
final class User
{
public function __construct(
public readonly int $id,
public readonly string $email,
private array $roles = [],
) {}
public function withEmail(string $email): static
{
return new static($this->id, $email, $this->roles);
}
}
$u = new User(1, 'a@example.com');
$u2 = $u->withEmail('b@example.com');
echo $u2->email, ' / original: ', $u->email, PHP_EOL;
try {
$u->email = 'hack@example.com';
} catch (Error $e) {
echo get_class($e), ': ', $e->getMessage(), PHP_EOL;
}
b@example.com / original: a@example.com
Error: Cannot modify readonly property User::$email
Fíjate en la clase de la excepción: es Error, no Exception. Un bloque catch (Exception $e) no la atrapa y el script muere. Atrapa Error (o Throwable) solo cuando de verdad lo quieres.
Una readonly class (8.2) vuelve readonly todas sus propiedades y prohíbe las propiedades dinámicas:
readonly class Point
{
public function __construct(public int $x, public int $y) {}
}
$p = new Point(1, 2);
$p->x = 10; // Error: Cannot modify readonly property Point::$x
$p->z = 3; // Error: Cannot create dynamic property Point::$z
Tres reglas de readonly que sorprenden, cada una de una ejecución real:
class A { public readonly $x; } -> Fatal error: Readonly property A::$x must have type
class A { public readonly int $x = 5; } -> Fatal error: Readonly property A::$x cannot have default value
$b->items[] = 3; (readonly array) -> Error: Cannot indirectly modify readonly property Bag::$items
Pero readonly es superficial. Una propiedad readonly que contenía un ArrayObject nos dejó agregarle elementos; el conteo pasó de 1 a 2. Readonly protege la referencia, no el objeto que está detrás.
clone-with de PHP 8.5, y la trampa en la que caímos
PHP 8.5 permite que clone reciba un array con nuevos valores de propiedades, lo que acorta mucho los métodos "with". Nuestro primer intento lo llamó desde fuera de la clase:
$p2 = clone($p, ['x' => 99]);
Fatal error: Uncaught Error: Cannot modify protected(set) readonly property Point::$x from global scope in ~/demo/a1_readonly.php:54
El mensaje explica la regla: una propiedad readonly es implícitamente protected(set), así que solo el código dentro de la clase (o de una hija) puede escribirla, incluso a través de clone-with. Movido a un método, funciona:
public function withX(int $x): static
{
return clone($this, ['x' => $x]);
}
// 1,2 -> 99,2
Interfaces, clases abstractas y traits
Una interfaz es un contrato: firmas de métodos, sin estado. Una clase abstracta puede tener estado y métodos terminados, pero no se puede instanciar. Un trait es copiar y pegar con apoyo del compilador: sus métodos se pegan dentro de la clase que lo usa.
interface Notifier
{
public function send(string $to, string $msg): bool;
}
abstract class BaseNotifier implements Notifier
{
private array $log = [];
public function send(string $to, string $msg): bool
{
$ok = $this->deliver($to, trim($msg));
$this->log[] = sprintf('%s %s %s', static::class, $to, $ok ? 'OK' : 'FAIL');
return $ok;
}
abstract protected function deliver(string $to, string $msg): bool;
public function log(): array { return $this->log; }
}
trait Retries
{
public function hello(): string { return 'Retries::hello'; }
protected function attempt(callable $fn, int $times = 3): bool
{
for ($i = 1; $i <= $times; $i++) {
if ($fn($i)) return true;
}
return false;
}
}
trait Greets
{
public function hello(): string { return 'Greets::hello'; }
}
final class MailNotifier extends BaseNotifier
{
use Retries, Greets {
Greets::hello insteadof Retries;
Retries::hello as protected retriesHello;
}
protected function deliver(string $to, string $msg): bool
{
return $this->attempt(fn(int $i) => $i >= 3); // succeeds on try 3
}
public function both(): string { return $this->hello() . ' + ' . $this->retriesHello(); }
}
$m = new MailNotifier();
var_dump($m->send('user@example.com', ' hi '));
echo $m->log()[0], PHP_EOL, $m->both(), PHP_EOL;
bool(true)
MailNotifier user@example.com OK
Greets::hello + Retries::hello
insteadof elige al ganador cuando dos traits definen el mismo método, y as conserva al perdedor con otro nombre (y aquí además le cambia la visibilidad). Sin ese bloque, PHP se niega a compilar la clase:
Fatal error: Trait method B::hello has not been applied as C::hello, because of collision with A::hello in ~/demo/a3b.php on line 4
Los otros dos errores que vas a ver en tu primera semana:
Fatal error: Class Sq contains 1 abstract method and must therefore be declared abstract or implement the remaining method (Shape::area) in ~/demo/a3c.php on line 3
Fatal error: Uncaught Error: Cannot instantiate abstract class Base in ~/demo/a3d.php:3
El primero es un error en tiempo de compilación (el archivo nunca llega a ejecutarse); el segundo es un Error en tiempo de ejecución que podrías atrapar. En PHP 8.5 los dos terminan ahora con un bloque Stack trace:, incluso los de compilación: es la nueva función de backtrace en errores fatales, no una señal de que algo más salió mal.
static vs self: late static binding
self significa "la clase en la que está escrita esta línea". static significa "la clase sobre la que se llamó el método". La diferencia solo aparece con herencia, que es justo donde viven los ORM y las clases base de modelos.
class Model
{
public static function createSelf(): self { return new self(); }
public static function createStatic(): static { return new static(); }
public static function table(): string { return strtolower(static::class) . 's'; }
public static function tableSelf(): string { return strtolower(self::class) . 's'; }
}
class Post extends Model {}
echo get_class(Post::createSelf()), PHP_EOL;
echo get_class(Post::createStatic()), PHP_EOL;
echo Post::table(), PHP_EOL;
echo Post::tableSelf(), PHP_EOL;
Model
Post
posts
models
Una segunda trampa tiene que ver con las propiedades estáticas. Una clase hija comparte la propiedad estática de la madre, salvo que la vuelva a declarar:
class Counter
{
protected static int $count = 0;
public static function inc(): int { return ++static::$count; }
}
class A extends Counter {}
class B extends Counter { protected static int $count = 100; }
A::inc(); A::inc();
echo 'A: ', A::inc(), ' Counter: ', Counter::inc(), ' B: ', B::inc(), PHP_EOL;
A: 3 Counter: 4 B: 101
A y Counter estaban contando en la misma variable. Si querías un contador por subclase, cada subclase tendría que declarar el suyo; mejor todavía, usa una propiedad de instancia y olvídate de los estáticos.
Enums: valores respaldados, from y tryFrom
Un enum (8.1) es un conjunto cerrado de valores que el sistema de tipos entiende. Un enum respaldado (backed) además tiene un valor string o int para la base de datos y el JSON.
enum Status: string
{
case Draft = 'draft';
case Published = 'published';
case Archived = 'archived';
public function label(): string
{
return match ($this) {
self::Draft => 'Draft',
self::Published => 'Live',
self::Archived => 'Archived',
};
}
public static function fromInput(?string $s): self
{
return self::tryFrom((string) $s) ?? self::Draft;
}
}
$s = Status::from('published');
echo $s->name, ' ', $s->value, ' ', $s->label(), PHP_EOL;
var_dump(Status::tryFrom('deleted'));
echo Status::fromInput(null)->name, PHP_EOL;
echo json_encode(['status' => Status::Archived]), PHP_EOL;
Status::from('deleted');
Published published Live
NULL
Draft
{"status":"archived"}
ValueError: "deleted" is not a valid backing value for enum Status
Usa from() con datos confiables (un valor de tu propia base de datos: un valor incorrecto es un bug, así que deja que lance la excepción) y tryFrom() con entrada del usuario (null significa "no es válido" y tú eliges el valor de respaldo).
Con declare(strict_types=1), un enum respaldado por int no acepta el string '3' que llega de $_GET: TypeError: Priority::from(): Argument #1 ($value) must be of type int, string given. Sin tipos estrictos, la misma llamada devolvió Priority::High. Convierte con (int) en la frontera.
Errores comunes con enums: qué pasa y cómo arreglarlo
Error 1: comparar un enum con un string. Suit::Hearts == 'Hearts' es bool(false). Sin error, sin warning: el if simplemente nunca se ejecuta. Solución: compara con el case (=== Suit::Hearts) o compara ->value en los enums respaldados.
Error 2: json_encode sobre un enum puro (sin respaldo). Devolvió false y echo no imprimió nada. json_last_error_msg() dijo Non-backed enums have no default serialization. Con JSON_THROW_ON_ERROR obtienes una JsonException con el mismo mensaje. Solución: dale un tipo de respaldo al enum si alguna vez sale del proceso.
Error 3: agregar un case y olvidar un match. Agregamos case Live y llamamos a un match que solo manejaba Draft:
Fatal error: Uncaught UnhandledMatchError: Unhandled match case Status::Live in ~/demo/a5d.php:4
PHP no comprueba la exhaustividad en tiempo de compilación (a diferencia de Swift o Dart; mira sus clases). Solución: mantén el match dentro del enum como método, para que el lugar donde agregas un case sea el mismo donde actualizas las etiquetas, y deja que un analizador estático como PHPStan marque el hueco.
Error 4: un typo en el nombre de una propiedad de una clase normal. $u->nmae = 'x' imprimió Deprecated: Creation of dynamic property U::$nmae is deprecated y siguió adelante. Solución: declara las propiedades, marca las clases de datos como readonly (lo que lo convierte en un Error) y trata los mensajes Deprecated como fallos durante el desarrollo.
First-class callables, property hooks y el pipe de PHP 8.5
La sintaxis de first-class callable (8.1) convierte cualquier función o método en un Closure con name(...). El viejo array [$obj, 'method'] sigue funcionando, pero un typo recién salía a la luz al ejecutarse:
$make = $slug->make(...); // Closure bound to $slug
print_r(array_map($make, ['Hello World!', ' Enums & Traits ']));
array_map([$slug, 'mkae'], $titles);
Array
(
[0] => hello-world
[1] => enums-traits
)
TypeError: array_map(): Argument #1 ($callback) must be a valid callback or null, class Slug does not have a method "mkae"
$slug->mkae(...) falla justo donde está escrito, con Error: Call to undefined method Slug::mkae(), que es más fácil de rastrear.
Los property hooks y la visibilidad asimétrica (8.4) reemplazan la mayoría de los getters y setters:
final class Account
{
public string $email {
set(string $value) {
$value = strtolower(trim($value));
if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException("invalid email: $value");
}
$this->email = $value;
}
}
public string $domain { // virtual: no storage
get => substr($this->email, strpos($this->email, '@') + 1);
}
public private(set) int $loginCount = 0; // read anywhere, write inside
public function __construct(string $email) { $this->email = $email; }
public function login(): void { $this->loginCount++; }
}
$a = new Account(' Alice@Example.COM ');
echo $a->email, ' | ', $a->domain, PHP_EOL; // alice@example.com | example.com
Escribir desde afuera dio tres resultados distintos, todos reales:
$a->loginCount = 99 -> Error: Cannot modify private(set) property Account::$loginCount from global scope
$a->domain = 'x.com' -> Error: Property Account::$domain is read-only
$a->email = 'not-an-email' -> InvalidArgumentException: invalid email: not-an-email
var_dump($a) no muestra el $domain virtual porque no tiene almacenamiento.
PHP 8.5 agrega el operador pipe |>, que pasa el valor de la izquierda como único argumento del callable de la derecha:
$slug = ' Hello PHP 8.5 World '
|> trim(...)
|> strtolower(...)
|> (fn(string $s) => preg_replace('/[^a-z0-9]+/', '-', $s))
|> (fn(string $s) => trim($s, '-'));
echo $slug, PHP_EOL; // hello-php-8-5-world
Lo que comprobamos en 8.5.6:
| Código | Resultado en 8.5.6 |
|---|---|
|> fn($s) => $s . '!' sin paréntesis |
Fatal error: Arrow functions on the right hand side of |> must be parenthesized |
|> str_replace('a', 'x', ...) (aplicación parcial) |
Parse error: syntax error, unexpected token ")": no existe en 8.5 |
|> intdiv(...) (necesita 2 argumentos) |
ArgumentCountError: intdiv() expects exactly 2 arguments, 1 given |
| un parámetro por referencia | Error: addOne(): Argument #1 ($a) could not be passed by reference |
array_first($xs), array_last($xs) (nuevas en 8.5) |
2, 3; array_first([]) es NULL |
se ignora el resultado de #[\NoDiscard] |
Warning: The return value of function withTax() should either be used or intentionally ignored by casting it as (void), … |
Autoloading sin Composer
Todo proyecto con Composer usa spl_autoload_register por debajo. Escribir a mano un loader PSR-4 lleva diez líneas y muestra lo que pasa:
// main.php — App\ => src/
spl_autoload_register(function (string $class): void {
$prefix = 'App\\';
if (!str_starts_with($class, $prefix)) {
return; // not ours: let another loader try
}
$file = __DIR__ . '/src/' . str_replace('\\', '/', substr($class, strlen($prefix))) . '.php';
echo "[autoload] $class\n";
if (is_file($file)) {
require $file;
}
});
$repo = new App\Repo\UserRepo(); // src/Repo/UserRepo.php, which uses App\Model\User
foreach ($repo->all() as $u) echo $u->id, ' ', $u->name, PHP_EOL;
var_dump(class_exists('App\Model\Missing'));
new App\Model\Missing();
[autoload] App\Repo\UserRepo
[autoload] App\Model\User
1 alice
2 bob
[autoload] App\Model\Missing
bool(false)
[autoload] App\Model\Missing
Fatal error: Uncaught Error: Class "App\Model\Missing" not found in ~/demo/autoload/main.php:25
Dos observaciones: use App\Model\User; no cargó nada; los archivos se cargan solo cuando una clase se usa por primera vez. Y una búsqueda fallida no se guarda en caché: el loader volvió a ejecutarse para la misma clase inexistente. Si tu loader hace trabajo costoso (recorrer directorios), ese costo se repite. Ojo también: en un servidor Linux, que distingue mayúsculas de minúsculas, App\model\User no va a encontrar Model/User.php, aunque en un disco de macOS con la configuración por defecto funcione.
Medido: objetos vs arrays para 100,000 filas
El consejo de siempre es "los arrays son más livianos que los objetos". Lo medimos. Cada fila es {id, name, age, active}; memory_get_usage() antes y después de construir 100,000 filas; PHP 8.5.6 CLI, Mac con Apple Silicon (M1 Pro), tres ejecuciones.
$rows[] = match ($mode) {
'assoc' => ['id' => $i, 'name' => $name, 'age' => 20 + $i % 50, 'active' => $i % 2 === 0],
'list' => [$i, $name, 20 + $i % 50, $i % 2 === 0],
'object' => new UserObj($i, $name, 20 + $i % 50, $i % 2 === 0), // 4 promoted typed props
'stdclass' => (object) ['id' => $i, 'name' => $name, /* … */],
};
| Forma | Memoria | Bytes/fila | Tiempo de construcción (mediana de 3) |
|---|---|---|---|
| Clase tipada | 17.5 MB | 183 | 15.6 ms |
| Array de lista | 26.4 MB | 277 | 9.3 ms |
| Array asociativo | 41.7 MB | 437 | 12.2 ms |
| stdClass | 46.5 MB | 487 | 13.2 ms |
La memoria fue idéntica en todas las ejecuciones. Un objeto con propiedades declaradas guarda sus cuatro valores en una tabla de slots fija; cada array asociativo lleva su propia tabla hash con las claves. Unos 61 bytes de cada fila son el string name, igual en todas las formas. Los objetos tardaron más en construirse (una llamada al constructor por fila), y activar OPcache no cambió las cifras de memoria. stdClass es lo peor de los dos mundos: una tabla hash dinámica como un array, más el overhead de objeto. Si mantienes muchos registros en memoria (un proceso de importación, un reporte), una clase readonly pequeña es a la vez más segura y más chica.
Tabla de decisión
| Necesitas | Usa | Por qué |
|---|---|---|
| Un conjunto fijo de valores (estado, rol) | enum respaldado |
los valores inválidos lanzan ValueError; el JSON funciona |
| Un contrato, varias implementaciones | interface |
test doubles, cambiar de driver |
| Estado compartido y un flujo fijo | abstract class |
template method; las hijas completan un paso |
| Unos pocos helpers en clases no relacionadas | trait |
no hace falta una madre común; resuelve las colisiones de forma explícita |
| Un value object / DTO | final readonly class |
inmutable, tipado, 2.4× más chico que un array asociativo aquí |
| Validación al asignar | property hook set (8.4+) |
sin código repetitivo de getters/setters |
| Solo lectura desde afuera, escribible por dentro | public private(set) (8.4+) |
contadores, IDs |
| Una factory en una clase base | new static() |
devuelve la subclase |
Límites honestos y notas de versión
- Todo se ejecutó solo en PHP 8.5.6 CLI. Las versiones mencionadas vienen del changelog de PHP, no de ejecutar versiones anteriores: promoción 8.0; enums, propiedades readonly y first-class callables 8.1; clases readonly y la deprecación de propiedades dinámicas 8.2; property hooks y visibilidad asimétrica 8.4; operador pipe, clone-with,
array_first/last,#[\NoDiscard]y backtraces en errores fatales 8.5. En un hosting con 8.3, los hooks y|>son errores de parseo: revisaphp -ven el servidor antes de usarlos. - Las cifras de memoria corresponden a esta forma de registro y al build de 64 bits de PHP 8.5; con más campos o strings largos la proporción cambia. Los tiempos de construcción son de pocos milisegundos y tienen ruido; no leas en ellos más que "los objetos tardaron algo más en crearse".
- No medimos el overhead de los property hooks en rutas de código muy usadas.
Ejercicio
Escribe un enum respaldado por int Role con Admin = 1, Editor = 2, Viewer = 3 y un método estático fromQuery(?string $raw): self que convierta $_GET['role'] en un rol, usando Viewer como respaldo para valores ausentes, no numéricos o desconocidos. Haz que funcione con strict_types=1.
Respuestas
<?php
declare(strict_types=1);
enum Role: int
{
case Admin = 1;
case Editor = 2;
case Viewer = 3;
public static function fromQuery(?string $raw): self
{
if ($raw === null || !ctype_digit($raw)) {
return self::Viewer;
}
return self::tryFrom((int) $raw) ?? self::Viewer;
}
}
foreach (['1', '2', '9', 'abc', null, '-1'] as $q) {
echo var_export($q, true), ' => ', Role::fromQuery($q)->name, PHP_EOL;
}
'1' => Admin
'2' => Editor
'9' => Viewer
'abc' => Viewer
NULL => Viewer
'-1' => Viewer
Sin la conversión (int), tryFrom('1') lanza un TypeError con tipos estrictos, porque tryFrom solo es tolerante con el valor, no con el tipo.
Lo que sigue
Preguntas frecuentes
¿Los objetos en PHP ocupan más memoria que los arrays?
No si declaras las propiedades. En PHP 8.5.6, 100,000 filas de cuatro campos ocuparon 17.5 MB como objetos de una clase tipada, 26.4 MB como arrays de lista, 41.7 MB como arrays asociativos y 46.5 MB como stdClass. Construir los objetos fue un poco más lento (unos 15.6 ms contra 12.2 ms de los arrays asociativos).
¿Qué diferencia hay entre self y static en PHP?
self es la clase donde está escrito el código; static es la clase sobre la que realmente se hizo la llamada (late static binding). Post::createSelf() devolvió un Model y Post::createStatic() devolvió un Post.
¿Ya puedo usar el operador pipe |> y los property hooks?
Los property hooks y la visibilidad asimétrica necesitan PHP 8.4; el operador pipe necesita PHP 8.5. Todo funcionó en PHP 8.5.6. Las arrow functions a la derecha de |> tienen que ir entre paréntesis o recibes un Fatal error en tiempo de compilación.