Qué hay de nuevo en PHP 8.5

PHP 8.5, previsto para lanzarse en noviembre de 2025, introduce mejoras clave que simplifican la vida de los desarrolladores. Estas incluyen:

• Operador pipe (|>): Permite encadenar funciones de forma más clara y reduciendo complejidad.
• Closures estáticos en expresiones constantes: Facilitan la definición de valores predeterminados en parámetros o atributos.
• Funciones de arrays: array_first() y array_last() hacen más sencillo acceder al primer o último elemento de un array.
• Depuración mejorada: Trazas de pila automáticas para errores fatales y nuevas herramientas como get_error_handler().
• Optimización de extensiones: Mejoras en cURL, DOM, MySQLi, PDO e Intl.

Estas características no solo hacen el código más limpio sino que también mejoran el rendimiento, especialmente en frameworks como Laravel. Además, PHP 8.5 refuerza su compatibilidad y estabilidad, siendo una actualización importante para proyectos modernos.

🔥 Noticias de PHP 8.5

Nuevas características del lenguaje en PHP 8.5

PHP 8.5 trae consigo dos mejoras clave que simplifican la escritura de código, lo hacen más legible y facilitan su mantenimiento. A continuación, te mostramos cómo funcionan estas novedades junto con ejemplos prácticos que estarán disponibles a partir del 20 de noviembre de 2025.

Operador Pipe (|>)

El operador pipe (|>) permite encadenar funciones de manera secuencial, eliminando la necesidad de usar variables temporales y reduciendo las anidaciones complejas. Este enfoque hace que el código siga un flujo lógico de izquierda a derecha, facilitando su comprensión.

Laravel News: "El operador |>, o 'pipe', acepta un callable de un solo parámetro a la derecha y le pasa el valor del lado izquierdo, evaluando al resultado del callable."

En términos simples, el operador |> toma el resultado de la expresión a su izquierda y lo pasa como argumento al callable de su derecha. Esto se traduce en un código más claro y fácil de leer. Comparemos un ejemplo tradicional con la nueva sintaxis:

// Antes de PHP 8.5 (anidado)
$result = array_filter(
    array_map(
        strtoupper(...),
        str_split(
            htmlentities("Hello World")
        )
    ),
    fn($v) => $v != 'O'
);

Con el operador pipe, el mismo código se simplifica considerablemente:

// PHP 8.5 (operador pipe)
$result = "Hello World"
    |> htmlentities(...)
    |> str_split(...)
    |> fn($x) => array_map(strtoupper(...), $x)
    |> fn($x) => array_filter($x, fn($v) => $v != 'O');

Closures estáticos en expresiones constantes

Otra mejora importante en PHP 8.5 es la posibilidad de usar closures estáticos en expresiones constantes, lo que permite definir valores predeterminados en parámetros, atributos y constantes de clase. Estos closures, al no depender de $this ni capturar variables externas, garantizan que su valor sea constante en tiempo de compilación.

PHP RFC: "La capacidad de usar Closures en expresiones constantes te permite escribir código más limpio, ya que puedes proporcionar callbacks o validadores por defecto directamente en firmas de funciones, atributos o constantes."

Un uso práctico de esta funcionalidad es la validación de datos mediante atributos:

final class Configuracion
{
    #[\Validator\Custom(static function (string $codigoIdioma): bool {
        return preg_match('/^[a-z][a-z]$/', $codigoIdioma);
    })]
    public string $codigoIdioma;
}

También resulta útil para generar casos de prueba dinámicos:

final class CalculadoraTest
{
    #[\Test\CaseGenerator(static function (): iterable {
        for ($i = -10; $i <= 10; $i++) {
            yield [$i, $i, 0];
            yield [$i, 0, $i];
            yield [0, $i, -$i];
        }
    })]
    public function testResta(int $minuendo, int $sustraendo, int $resultado)
    {
        assert(Calculadora::restar($minuendo, $sustraendo) === $resultado);
    }
}

Además, frameworks y bibliotecas pueden utilizar esta funcionalidad para mejorar la serialización de datos. Por ejemplo:

final class EntradaLog
{
    public string $mensaje;

    #[\Serialize\Custom(static function (string $severidad): string {
        return strtoupper($severidad);
    })]
    public string $severidad;
}

Estas características no solo hacen que PHP 8.5 sea más expresivo, sino que también permiten escribir código más modular y eficiente, adaptándose mejor a las necesidades de los desarrolladores modernos.

Nuevas funciones integradas y actualizadas

PHP 8.5 trae consigo herramientas pensadas para simplificar tareas comunes y mejorar la depuración. Estas funciones no solo eliminan código redundante, sino que también hacen que el propósito del desarrollador sea más claro y directo. Aquí te contamos más sobre estas novedades y cómo pueden transformar tu flujo de trabajo.

Funciones de array: array_first y array_last

Con las nuevas funciones array_first() y array_last(), ahora es mucho más sencillo obtener el primer o último valor de un array. Estas funciones complementan a array_key_first() y array_key_last() de PHP 7.3, pero en lugar de trabajar con claves, se centran en los valores. Antes de PHP 8.5, lograr esto requería soluciones menos elegantes como reset() (que alteraba el puntero interno del array) o métodos más complejos como array_values($array)[0]. Ahora, el código es mucho más limpio y entendible:

$usuarios = ['Alice', 'Bob', 'Charlie'];
$primerUsuario = array_first($usuarios);  // 'Alice'
$ultimoUsuario = array_last($usuarios);   // 'Charlie'

$datos = ['nombre' => 'Juan', 'edad' => 30, 'ciudad' => 'Madrid'];
echo array_first($datos); // 'Juan'
echo array_last($datos);  // 'Madrid'

$vacio = [];
var_dump(array_first($vacio)); // null
var_dump(array_last($vacio));  // null

La gran ventaja aquí es que estas funciones no alteran el puntero interno del array, lo que garantiza un comportamiento más predecible y seguro. Además, hacen que el código sea más sencillo de leer y mantener, especialmente en proyectos complejos.

Mejoras en la depuración: backtrace mejorado

PHP 8.5 también ha dado un paso importante en la depuración, introduciendo trazas de pila automáticas para errores fatales. Antes, los desarrolladores solo recibían información básica como el tipo de error, una breve descripción, el archivo y la línea donde ocurrió el problema. Esto podía complicar el diagnóstico en aplicaciones grandes.

Con la nueva configuración INI fatal_error_backtraces, activada de forma predeterminada, ahora es posible obtener una traza completa de la ejecución cuando ocurre un error fatal. Es similar a las trazas que se generan con las excepciones, pero aplicadas a errores fatales. Además, se han tomado medidas para proteger la privacidad de los datos, ya que las trazas respetan atributos como SensitiveParameter, evitando que información confidencial se registre en los logs.

Otra novedad interesante es que ahora puedes usar error_get_last() para acceder a la traza dentro de closures, lo que permite a frameworks y aplicaciones manejar estos errores con mayor flexibilidad. Por si fuera poco, PHP 8.5 introduce las funciones get_error_handler() y get_exception_handler(), facilitando la implementación de manejadores personalizados en frameworks.

Estas mejoras no solo hacen que depurar sea más fácil, sino que también abren la puerta a un manejo de errores más sofisticado, adaptado a las necesidades de cada proyecto. Y esto es solo el principio de lo que PHP 8.5 tiene preparado.

Actualizaciones de extensiones y biblioteca estándar

Además de las mejoras en el lenguaje y las funciones integradas, PHP 8.5 también trae actualizaciones importantes en sus extensiones, enfocándose en optimizar el rendimiento y la gestión de recursos. Estas mejoras abarcan desde la gestión de peticiones HTTP hasta la manipulación del DOM y el acceso a bases de datos, fortaleciendo el ecosistema de PHP.

Actualizaciones de cURL

La extensión cURL ahora incluye la función curl_multi_get_handles(), que permite recuperar todos los manejadores activos en una sesión multi-cURL. Esto simplifica enormemente la gestión de peticiones HTTP paralelas, facilitando la comunicación simultánea con múltiples APIs.

Aquí tienes un ejemplo práctico:

$ch1 = curl_init('https://example.com/foo');
$ch2 = curl_init('https://example.com/bar');
curl_multi_add_handle($cm, $ch1);
curl_multi_add_handle($cm, $ch2);
curl_multi_get_handles($cm);
// [$ch1, $ch2]

Con esta función, ya no es necesario realizar un seguimiento manual de los manejadores en sesiones multi-cURL, lo que reduce la complejidad del código.

Actualizaciones del DOM

La extensión DOM en PHP 8.5 también recibe mejoras significativas para facilitar la manipulación de documentos HTML y XML. Ahora incluye propiedades y métodos como outerHTML e insertAdjacentHTML, que están alineados con los estándares web modernos. Estas herramientas hacen que trabajar con contenido estructurado sea más intuitivo y eficiente.

Mejoras en MySQLi y PDO

En el ámbito de las bases de datos, PHP 8.5 introduce nuevas funcionalidades en las extensiones MySQLi y PDO. Entre las novedades destacan herramientas para recopilar estadísticas de memoria y nuevas constantes para SQLite, lo que permite un mejor monitoreo del rendimiento en consultas y una gestión más eficiente de recursos. Estas mejoras son especialmente útiles para aplicaciones que manejan grandes cantidades de datos o que necesitan optimizar el uso de memoria.

Mejoras en la extensión Intl

La extensión Intl también recibe actualizaciones importantes en esta versión. Una de las más relevantes es la incorporación de la función locale_is_right_to_left() y el método Locale::isRightToLeft(), que permiten identificar si un idioma se lee de derecha a izquierda. Esto resulta crucial para aplicaciones que necesitan soportar idiomas como árabe o hebreo.

locale_is_right_to_left('en-US');  // false
locale_is_right_to_left('ar-SA');  // true
locale_is_right_to_left('he-IL');  // true

Además, se introduce la clase IntlListFormatter, diseñada para formatear listas según las reglas regionales, mejorando el soporte multilingüe. Por ejemplo:

$formatter = new IntlListFormatter('en', IntlListFormatter::TYPE_CONJUNCTION);
echo $formatter->format(['Red', 'Green', 'Blue']); // "Red, Green, and Blue"

Estas actualizaciones refuerzan el enfoque de PHP 8.5 en ofrecer herramientas modernas y adaptadas a las necesidades actuales, especialmente en entornos globales y multilingües. Con estas mejoras, PHP sigue consolidándose como una opción potente y versátil para desarrolladores.

Mejoras en rendimiento y experiencia del desarrollador

PHP 8.5 no solo trae mejoras en rendimiento, sino también ajustes que hacen que el día a día de los desarrolladores sea más sencillo, ayudando a escribir y mantener código de forma más eficiente.

Optimizaciones de rendimiento

Las mejoras en rendimiento de PHP 8.5 se construyen sobre los avances logrados en versiones anteriores de la serie 8.x. Estas versiones han demostrado ser mucho más rápidas en comparación con las series 7.x. Por ejemplo, WordPress ejecutándose en PHP 8.0 procesa un 18,4% más de peticiones por segundo en comparación con PHP 7.4, mientras que Laravel en PHP 8.0 maneja un 8,5% más de peticiones que en PHP 7.3. Actualmente, PHP impulsa el 76% de los sitios web activos en internet.

Entre las principales mejoras de rendimiento destacan el uso del compilador Just-In-Time (JIT), la optimización en las llamadas a funciones y las declaraciones de tipos. Estas características no solo mejoran la velocidad de ejecución, sino que también contribuyen a una experiencia de desarrollo más fluida. Por ejemplo, frameworks como CodeIgniter han experimentado incrementos de rendimiento de hasta un 42% con las versiones más recientes de PHP.

Mejor legibilidad del código y menos código repetitivo

PHP 8.5 introduce herramientas que hacen que el código sea más limpio y fácil de mantener, eliminando redundancias y aumentando la productividad.

El operador pipe y las funciones array_first() y array_last() son ejemplos claros de cómo PHP 8.5 simplifica el desarrollo. Estas funcionalidades permiten escribir código más legible y evitar el uso de variables temporales innecesarias. Esto hace que operaciones complejas se conviertan en secuencias claras, eliminando métodos más largos que podrían generar errores no deseados.

En el desarrollo de APIs, PHP 8.5 facilita la definición de comportamientos predeterminados directamente en los parámetros mediante closures. Esto simplifica la lógica de los controladores y mejora la reutilización del código en las respuestas. Además, las expresiones callable de primera clase en constantes permiten estructurar manejadores de rutas más limpios, algo especialmente útil en aplicaciones Laravel.

Por otro lado, las mejoras en herramientas de depuración han sido notables. Ahora se incluyen trazas de pila automáticas en errores fatales y nuevas opciones como la CLI "php --ini=diff", que permite identificar configuraciones INI personalizadas de manera rápida, haciendo que la resolución de problemas sea más ágil.

En resumen, estas novedades no solo optimizan el rendimiento, sino que también ofrecen un entorno de desarrollo más cómodo y eficiente, con código más claro y tiempos de desarrollo más cortos para aplicaciones modernas en PHP.

Uso de PHP 8.5 con proyectos Laravel

PHP 8.5 ofrece una base sólida para que Laravel brille aún más, permitiendo escribir código más claro y eficiente. Las nuevas funcionalidades de esta versión encajan perfectamente con la filosofía de Laravel, que busca hacer del desarrollo web una experiencia fluida y expresiva. Veamos cómo estas mejoras se integran en el ecosistema de Laravel.

Compatibilidad de Laravel con PHP 8.5

Las características avanzadas de PHP 8.5 complementan el flujo de trabajo de Laravel de forma natural. Por ejemplo, el operador pipe (|>) facilita la manipulación de datos al permitir encadenar transformaciones sin necesidad de variables intermedias. Esto resulta especialmente útil al trabajar con objetos de transferencia de datos (DTOs) o colecciones de Eloquent, donde el procesamiento, validación y formateo de datos se realiza de manera más limpia.

Otra novedad, la promoción de propiedades finales, simplifica la creación de objetos inmutables como value objects o DTOs. Esto es ideal para proteger propiedades que no deben cambiar tras ser inicializadas, como identificadores únicos.

Además, las funciones array_first() y array_last() simplifican tareas comunes en controladores y servicios al acceder a elementos específicos de arrays, como resultados de consultas o datos provenientes de formularios, eliminando la necesidad de métodos más extensos.

Los closures en expresiones constantes también son un gran avance, ya que permiten definir comportamientos predeterminados directamente en parámetros. Esto es especialmente útil en respuestas de API y ayuda a reducir la complejidad en la lógica de controladores.

"PHP 8.5 is about refinement: less friction, fewer surprises, and more expressive syntax." - Hector Canovas

Actualización a PHP 8.5

Si estás considerando actualizar a PHP 8.5, es importante planificar cuidadosamente el proceso para evitar contratiempos. Laravel, con su ciclo de soporte de 18 meses para correcciones de errores y dos años para parches de seguridad, proporciona un marco confiable para esta transición.

Primero, actualiza el archivo composer.json para asegurar la compatibilidad con PHP 8.5 y revisa las dependencias de terceros. Es fundamental consultar la guía de actualización de Laravel para identificar y corregir cualquier cambio incompatible que pueda afectar a tu proyecto. También verifica que todas las extensiones PHP necesarias estén habilitadas.

Una vez realizada la actualización, ejecuta tus tests para identificar posibles problemas de compatibilidad, especialmente en funciones que dependen de características específicas o librerías externas. Para proyectos más grandes, herramientas como Laravel Shift pueden ser de gran ayuda para automatizar y agilizar este proceso.

Por último, no olvides que los benchmarks de Laravel muestran mejoras destacadas en rendimiento con PHP 8.5. Esto se debe, en parte, a las optimizaciones del compilador Just-In-Time (JIT), que pueden marcar una diferencia notable en aplicaciones Laravel con lógica intensiva o que manejan grandes volúmenes de datos. Actualizar no solo mejora la eficiencia, sino que también asegura que tu proyecto esté preparado para el futuro.

Conclusión: aspectos clave de PHP 8.5

PHP 8.5 promete ser un paso adelante hacia un desarrollo más ágil y claro. Con su lanzamiento previsto para el 20 de noviembre de 2025, esta versión busca facilitar la vida diaria de los desarrolladores al introducir herramientas que simplifican y modernizan el código.

Entre las mejoras más destacadas están el operador pipe, nuevas funciones para trabajar con arrays y la posibilidad de usar closures estáticos en expresiones constantes. Estas características no solo reducen la duplicación de código, sino que también hacen que sea más fácil de leer y mantener.

"PHP 8.5 es una versión centrada en la productividad del desarrollador. Aunque no introduce nuevos paradigmas radicales, sus mejoras específicas reducen el código repetitivo, mejoran la fiabilidad de la depuración, modernizan patrones heredados y simplifican el desarrollo de API y microservicios" - Amigoways

El impacto de estas novedades es especialmente notable para quienes trabajan con Laravel. PHP 8.5 ofrece una base sólida que se alinea perfectamente con la filosofía de este framework, ayudando a escribir código más limpio y fácil de mantener.

Además, esta versión trae mejoras importantes en el manejo de errores, como trazas de pila más detalladas para errores fatales, así como actualizaciones en extensiones como cURL y DOM. También incluye optimizaciones de rendimiento que serán especialmente útiles para aplicaciones con lógica compleja. Con dos años de soporte activo para errores y dos años más de actualizaciones de seguridad hasta noviembre de 2029, PHP 8.5 asegura una estabilidad a largo plazo.

Para sacar el máximo provecho de estas novedades, es recomendable auditar el código actual, incorporar el operador pipe para simplificar encadenamientos y aprovechar las nuevas funciones de arrays para operaciones comunes. Estas mejoras no solo hacen que el desarrollo sea más eficiente, sino que también refuerzan a PHP 8.5 como una base sólida para proyectos Laravel en el futuro.

FAQs

¿Qué ventajas ofrece el nuevo operador pipe (|>) en PHP 8.5 para el rendimiento y la claridad del código?

PHP 8.5 introduce el operador pipe (|>), una herramienta que hace que encadenar funciones sea mucho más claro y fácil de leer. En lugar de anidar funciones dentro de otras, este operador permite estructurar el flujo de datos de forma lineal, haciendo que el código sea más comprensible y, sobre todo, más sencillo de mantener.

¿Y qué pasa con el rendimiento? Aunque podría pensarse que este operador añade algo de sobrecarga, PHP 8.5 ha sido optimizado para que su uso sea tan rápido como las llamadas anidadas tradicionales. En otras palabras, puedes escribir código más limpio sin preocuparte por afectar la velocidad de ejecución. Es una solución perfecta para proyectos modernos donde la claridad y la simplicidad del código son clave.

¿Qué ventajas ofrecen las nuevas funciones array_first() y array_last() en PHP 8.5 frente a métodos anteriores?

Con la llegada de PHP 8.5, las funciones array_first() y array_last() hacen que acceder al primer o último elemento de un array sea mucho más sencillo. Ya no necesitas preocuparte por manejar el puntero interno del array ni escribir líneas extra de código para lograrlo. Todo se reduce a una solución directa y eficiente.

Estas funciones no solo simplifican el trabajo, sino que también aportan un nivel extra de seguridad al código. Esto es especialmente útil cuando trabajas con arrays dinámicos o estructuras más complejas, ya que disminuyen las posibilidades de cometer errores. Como resultado, el código es más claro, fácil de leer y mucho más sencillo de mantener a largo plazo.

¿Cómo facilitan las trazas de pila automáticas la depuración de errores fatales en PHP 8.5?

En PHP 8.5, las trazas de pila automáticas proporcionan una visión detallada del recorrido del código que desembocó en un error fatal. Incluso en situaciones donde antes no se generaba información de depuración, ahora es posible obtener datos claros y útiles. Esto ayuda a los desarrolladores a localizar la causa del problema de manera más rápida y precisa, algo especialmente valioso en entornos de producción.

Con esta funcionalidad, rastrear el origen de errores críticos se vuelve mucho más sencillo, lo que disminuye el tiempo dedicado al diagnóstico y contribuye a mantener las aplicaciones más estables y confiables.