Novedades de PHP 8.3 y las versiones siguientes

Hola, ¿cómo están? Continuando con el curso de PHP, hoy repasamos las novedades que trajo PHP 8.3 y las versiones que la rodean.

Esta lección tiene un objetivo práctico: que cuando veas código moderno reconozcas lo que estás mirando, y que sepas qué puedes usar según la versión que tenga tu servidor.

¡Empecemos!

Por qué importa la versión

Antes de las novedades, algo que conviene tener claro: PHP mantiene cada versión unos dos años con soporte activo y otro más con parches de seguridad. Después, deja de recibir correcciones.

Trabajar con una versión sin soporte no es solo perderse funciones bonitas: es tener un servidor con fallos de seguridad conocidos y sin parche. Es la razón número uno para actualizar.

Puedes comprobar tu versión con:

php --version

Novedades de PHP 8.3

Constantes de clase tipadas

Ahora las constantes pueden declarar su tipo:

<?php
class Configuracion
{
    const string ENTORNO = 'produccion';
    const int MAX_INTENTOS = 3;
    const float IVA = 0.13;
}

Sirve sobre todo en herencia: impide que una clase hija redefina la constante con un tipo distinto.

json_validate

Antes, para saber si una cadena era JSON válido había que decodificarla y comprobar el error, gastando memoria en construir algo que quizá ibas a descartar:

<?php
// Antes
json_decode($cadena);
$valido = json_last_error() === JSON_ERROR_NONE;

// Desde 8.3
$valido = json_validate($cadena);

Es mucho más eficiente cuando validas archivos grandes o peticiones de una API.

El atributo Override

Marca explícitamente que un método sobrescribe al del padre:

<?php
class Base
{
    public function procesar(): void {}
}

class Hija extends Base
{
    #[\Override]
    public function procesar(): void {}
}

¿Para qué sirve? Si mañana alguien renombra el método en la clase padre, PHP falla al compilar en lugar de dejar tu método huérfano ejecutándose sin que nadie lo llame. Es un error silencioso muy difícil de detectar, y este atributo lo convierte en visible.

Va bien de la mano de lo que vimos en herencia.

Clonado profundo de propiedades readonly

Las propiedades readonly no podían modificarse ni siquiera al clonar. Desde 8.3 sí, dentro de __clone():

<?php
class Documento
{
    public function __construct(
        public readonly DateTimeImmutable $creado,
    ) {}

    public function __clone(): void
    {
        $this->creado = new DateTimeImmutable();
    }
}

Resuelve un problema real: hacer una copia de un objeto inmutable cambiando solo un dato.

getBytesFromString

Genera una cadena aleatoria a partir de un conjunto de caracteres:

<?php
$generador = new Random\Randomizer();
$codigo = $generador->getBytesFromString('ABCDEFGHJKMNPQRSTUVWXYZ23456789', 8);

Fíjate en el detalle del conjunto: sin I, O, 0 ni 1, que se confunden entre sí. Perfecto para códigos que alguien va a leer y teclear.

Lo que trajeron las versiones anteriores

Muchas de las funciones que usamos durante el curso llegaron con estas versiones. Vale la pena situarlas.

PHP 8.0

• Promoción de propiedades en el constructor.
• La expresión match, con comparación estricta.
• Argumentos con nombre.
• El operador ?->, que evita errores al encadenar sobre valores nulos:

<?php
$ciudad = $usuario?->direccion?->ciudad;   // null si algo falta

• Tipos de unión: int|string.
• JIT, una mejora interna de rendimiento.

PHP 8.1

• Enumeraciones, que son de lo más útil que llegó al lenguaje:

<?php
enum EstadoPedido: string
{
    case Pendiente = 'pendiente';
    case Pagado = 'pagado';
    case Enviado = 'enviado';

    public function etiqueta(): string
    {
        return match($this) {
            self::Pendiente => 'En revisión',
            self::Pagado => 'Pago confirmado',
            self::Enviado => 'En camino',
        };
    }
}

$estado = EstadoPedido::Pagado;
echo $estado->etiqueta();

Sustituyen a las constantes de clase que vimos en su momento, con una ventaja enorme: son un tipo. Una función que recibe EstadoPedido no puede recibir un texto cualquiera.

• Propiedades readonly.
• never como tipo de retorno, para funciones que siempre lanzan o terminan.

PHP 8.2

• Clases readonly completas, en vez de propiedad por propiedad.
• Tipos true, false y null como tipos independientes.
• Prohibición de crear propiedades dinámicas, lo que evita errores por escribir mal el nombre de una propiedad.

Qué versión usar

La recomendación práctica: la versión estable más reciente que soporte tu hosting.

Si mantienes un proyecto antiguo, actualiza por etapas: 7.4 → 8.0 → 8.1 → 8.2. Cada salto tiene su guía de migración oficial, y hacerlo de a poco es mucho menos doloroso que un salto grande.

Antes de actualizar en producción, prueba en local. Con Laragon puedes tener varias versiones instaladas y cambiar entre ellas con un clic, justamente para esto.

Para cerrar

PHP lleva varios años de evolución rápida, y las versiones 8.x lo dejaron bastante lejos de la fama que arrastra. Enumeraciones, match, promoción de propiedades, readonly y tipado estricto son mejoras que cambian de verdad cómo se escribe el código.

Con esto cerramos el recorrido principal del curso de PHP. Lo que viene son cinco temas complementarios que no cubrimos y que vas a necesitar en cualquier proyecto real, empezando por los formularios.

Saludos y éxitos.