PHP 8.6: lo que ya está confirmado y cómo prepararse antes de noviembre

PHP 8.6 no está aún disponible: sale en noviembre de 2026. Pero el proceso de diseño del lenguaje es público, las RFCs se votan en wiki.php.net con transparencia total y ya hay suficiente material aprobado para saber con bastante certeza qué va a traer. Escribir sobre PHP 8.6 en marzo de 2026 tiene sentido por una razón concreta: algunas features aprobadas requieren cambios en la arquitectura de los proyectos para adoptarlas bien, y es mejor pensarlo ahora que cuando salga la versión estable en plena vorágine de fin de año.

Este artículo cubre únicamente las RFCs que ya han sido aceptadas o que tienen votos suficientes para considerarlas prácticamente aprobadas. Nada de especulación sobre features en discusión que pueden ser rechazadas.

Partial Function Application: el ? que cambia cómo componemos funciones

La RFC más impactante de PHP 8.6 ya tiene votos suficientes para considerarla aprobada. El operador ? en una llamada a función crea una función parcialmente aplicada: un nuevo callable que espera los argumentos no especificados.

// Sin partial application — patrón verbose actual
$multiplicarPorDos = fn(int $n) => $n * 2;
$resultados = array_map($multiplicarPorDos, [1, 2, 3, 4, 5]);
// [2, 4, 6, 8, 10]

// PHP 8.6 — partial application
function multiplicar(int $a, int $b): int { return $a * $b; }

$multiplicarPorDos = multiplicar(2, ?);
$resultados = array_map($multiplicarPorDos, [1, 2, 3, 4, 5]);
// [2, 4, 6, 8, 10]

El ? puede aparecer en cualquier posición:

function dividir(int $dividendo, int $divisor): float {
    if ($divisor === 0) throw new \DivisionByZeroError();
    return $dividendo / $divisor;
}

$dividirEntre10 = dividir(?, 10);
echo $dividirEntre10(100); // 10

$dividir100Entre = dividir(100, ?);
echo $dividir100Entre(4);  // 25

Partial application con métodos de clase

class Formateador {
    public function formatearMoneda(float $importe, string $moneda): string {
        return number_format($importe, 2) . ' ' . $moneda;
    }
}

$formateador = new Formateador();
$formatearEuros = $formateador->formatearMoneda(?, 'EUR');
echo $formatearEuros(1234.56); // "1,234.56 EUR"

// Con métodos estáticos
$parsearFechaES = DateTime::createFromFormat('d/m/Y', ?);
$fecha = $parsearFechaES('25/12/2026');

Combinado con el pipe operator de PHP 8.5

Donde PHP 8.6 brilla de verdad es en combinación con el operador pipe de PHP 8.5. Juntos permiten pipelines de procesamiento limpios que antes eran imposibles de escribir en PHP:

// PHP 8.5 pipe + PHP 8.6 partial application
$resultadoFinal = $pedidos
    |> array_filter(?, fn($p) => $p['estado'] === 'pendiente')
    |> array_map(?, fn($p) => $p['importe'] * 1.21)
    |> array_sum(?);

Este nivel de composición funcional era prácticamente imposible de escribir limpiamente en PHP antes de estas dos versiones.

clamp() nativo: fin de los min/max anidados

Otra RFC aprobada añade la función clamp(), que restringe un valor a un rango [min, max]. La mayoría de proyectos PHP implementan esto como helper porque no existe de forma nativa, obligando al patrón min(max($valor, $min), $max) que es difícil de leer:

// Patrón actual — correcto pero poco legible
$porcentaje = min(max($valor, 0), 100);
$precio     = min(max($precioCalculado, $precioMinimo), $precioMaximo);

// PHP 8.6 — clamp() nativo
$porcentaje = clamp($valor, 0, 100);
$precio     = clamp($precioCalculado, $precioMinimo, $precioMaximo);

// Funciona con enteros y floats
$temperatura = clamp($sensorReading, -273.15, 1000.0);

En código financiero o de procesamiento de datos donde los rangos son constantes, clamp() elimina una clase entera de bugs sutiles que aparecen cuando el orden de min y max se invierte accidentalmente.

Mejoras en el tipo never

PHP 8.6 expande el uso del tipo never a más contextos. never indica que una función nunca retorna normalmente (siempre lanza una excepción o llama a exit()):

// PHP 8.5 — never solo en return type de funciones
function lanzarError(string $mensaje): never {
    throw new RuntimeException($mensaje);
}

// PHP 8.6 — never también en propiedades y tipos unión
class GestorErrores {
    // Callable que siempre lanza — tipado estrictamente
    private Closure $manejadorFatal;
}

// Tipos unión con never para narrowing más preciso
function procesarResultado(int|never $valor): int {
    return $valor * 2; // $valor siempre es int aquí
}

Atributos de validación en parámetros

Una RFC en votación final con alta probabilidad de aprobarse añadiría Attributes de validación en parámetros de función:

// Alta probabilidad de estar en PHP 8.6
function crearUsuario(
    #[MinLength(3), MaxLength(50)] string $nombre,
    #[Email]                              string $email,
    #[Min(18), Max(120)]                  int    $edad,
): Usuario {
    // Sin validación manual — PHP lanza TypeError si no se cumplen
    return new Usuario($nombre, $email, $edad);
}

Si esta RFC se aprueba antes del feature freeze, será el cambio más significativo en el sistema de tipos de PHP desde los union types de 8.0.

Cómo preparar tu código para PHP 8.6 ya

Adopta PHP 8.5 ahora. Partial function application de PHP 8.6 se complementa directamente con el pipe operator de PHP 8.5. Si ya estás en 8.5, el salto a 8.6 será más natural y el código que escribas en 8.5 se beneficiará inmediatamente de las nuevas features.

Elimina los helpers `clamp()` personalizados. La mayoría de proyectos tienen alguna función clamp, between o restrict en un helper. Márcalas con @deprecated ya. Cuando llegue PHP 8.6, la migración será un find & replace.

Busca el patrón `min(max(...))` en toda la base de código y añade un comentario // TODO: migrar a clamp() en PHP 8.6. Tener esa lista preparada hace que la actualización sea un trabajo de tarde.

Errores comunes al adoptar versiones nuevas de PHP

Actualizar en producción sin staging. Cada versión mayor de PHP tiene algún cambio de comportamiento en funciones internas. Valida siempre en un entorno idéntico a producción antes de actualizar.

Usar RCs en producción. Las versiones Release Candidate son para testing. Espera siempre a la versión estable 8.6.0 antes de actualizar proyectos en producción.

Extensiones sin soporte para la nueva versión. xdebug, imagick, redis y otras extensiones populares pueden no tener soporte para PHP 8.6 el día del lanzamiento. Verifica la compatibilidad de todas tus extensiones antes de planificar la actualización.

No leer el UPGRADE.md antes de migrar. El repositorio de PHP publica un documento de cambios incompatibles para cada versión. Leerlo antes de actualizar ahorra horas de debugging.

Conclusión

PHP 8.6 completa el trabajo empezado en PHP 8.5. La partial function application combinada con el pipe operator crea un estilo de programación funcional en PHP que hasta hace dos versiones era imposible escribir limpiamente. clamp() es pequeño pero resuelve un patrón que todos repetimos. Y las mejoras en el sistema de tipos hacen al lenguaje más expresivo y seguro.

Noviembre de 2026 está a ocho meses. Tiempo suficiente para adoptar PHP 8.5, familiarizarte con sus features y preparar la base de código. El objetivo es que cuando salga 8.6, el upgrade sea una tarde de trabajo, no una refactorización de semanas.