¿Qué características principales agregó PHP 8.x?

Question

Accepted Answer

**PHP 8.x** (8.0–8.3) trajo mejoras importantes que modernizaron el lenguaje — rendimiento (JIT), nuevas comodidades de sintaxis y tipado más sólido. Conocer estas características es importante para escribir PHP moderno e idiomático y reconocerlas en bases de código contemporáneas.

## Características clave de PHP 8.0

```php
// 1. Named arguments — pass by parameter name, skip optional ones
setCookie(name: "theme", value: "dark", httponly: true);

// 2. Constructor property promotion — declare + assign properties in the signature
class Point {
    public function __construct(public int $x, public int $y) {}   // no boilerplate
}

// 3. Union types
function process(int|string $id): void {}

// 4. The match expression — value-returning, strict, no fall-through
$result = match($status) {
    200, 201 => "success",
    404 => "not found",
    default => "unknown",
};

// 5. Nullsafe operator — short-circuit on null in a chain
$city = $user?->address?->city;   // null if any link is null (no error)

// 6. The JIT compiler (performance for CPU-bound code)
```

## Características de PHP 8.1

```php
// Enums — first-class enumerated types (finally!)
enum Status: string {
    case Active = 'active';
    case Inactive = 'inactive';
}

// Readonly properties — immutable after initialization
class User { public function __construct(public readonly string $id) {} }

// First-class callable syntax
$fn = strlen(...);    // create a closure from a function

// Pure intersection types: function f(A&B $x)
// Fibers (low-level async primitive)
```

## Características de PHP 8.2 y 8.3

```php
// 8.2: readonly classes, disjunctive normal form (DNF) types, null/false/true as types
readonly class DTO { public function __construct(public string $name) {} }

// 8.3: typed class constants, #[\Override] attribute, json_validate(), dynamic class constant fetch
class Config { const string VERSION = "1.0"; }   // typed constant
```

## Por qué importa (los temas)

```text
✓ Less boilerplate — constructor promotion, named args, match, nullsafe
✓ Stronger typing — union/intersection types, enums, readonly, typed constants
✓ Better performance — JIT, plus general engine speedups each release
✓ More expressive, safer, modern syntax overall
```

## Por qué es importante

Comprender las características principales de PHP 8.x es importante para escribir PHP moderno e idiomático y para reconocer estas construcciones en bases de código actuales — los lanzamientos 8.x representan una modernización significativa del lenguaje que mejoró dramáticamente su expresividad, seguridad de tipos y rendimiento, ayudando a deshacerse de la reputación anticuada de PHP.

Varias características son ahora herramientas cotidianas en PHP moderno: **promoción de propiedades del constructor** (eliminación de código boilerplate repetitivo), **argumentos nombrados** (llamadas legibles y flexibles), **expresión `match`** (una alternativa más segura que devuelve valor a switch), **operador nullsafe** (`?->`, manejo limpio de null en cadenas), y especialmente **enums** (PHP 8.1 — tipos enumerados de primera clase, ampliamente utilizados para conjuntos de constantes seguros de tipos) y **propiedades/clases readonly** (para inmutabilidad).

Estos reducen el boilerplate, fortalecen el tipado y hacen que el código sea más expresivo y seguro.

Conocer estas características es esencial para leer y escribir PHP actual (ya que los frameworks modernos y las bases de código las usan extensamente), para elegir el enfoque moderno idiomático sobre patrones antiguos, y para comprender por qué el PHP moderno es un lenguaje capaz y bien diseñado en lugar del inconsistente de su reputación inicial.

Mantenerse al día con la evolución del lenguaje — sabiendo qué agregó cada lanzamiento 8.x y usando estas características apropiadamente — es un conocimiento importante que distingue a los desarrolladores que escriben PHP moderno y profesional de aquellos atrapados en patrones anticuados, y refleja fluidez con el estado contemporáneo del lenguaje.