Asignatura: Tecnologías para el Desarrollo de Aplicaciones Web.

Tema: Diferencias entre PHP 7 y PHP 8.

La siguiente tabla muestra los cambios en la última versión de PHP 8.

PHP 7 PHP 8
 Argumentos con nombre
Especifica sólo los parámetros obligatorios, omitiendo los opcionales. Los argumentos son independientes del orden y
autodocumentados.
htmlspecialchars($string, ENT_COMPAT | htmlspecialchars($string,
ENT_HTML401, 'UTF-8', false); double_encode: false);

 Atributos
En lugar de anotaciones de PHPDoc, ahora puede usar metadatos estructurados con la sintaxis nativa de PHP.
class PostsController{ class PostsController{
/** #[Route("/api/posts/{id}", methods:
* @Route("/api/posts/{id}", ["GET"])]
methods={"GET"}) public function get($id) { /* ... */ }
*/ }
public function get($id) { /* ... */ }
}

 Promoción de la propiedad del constructor

Menos código repetitivo para definir e inicializar propiedades.
class Point { class Point {
public float $x; public function __construct(
public float $y; public float $x = 0.0,
public float $z; public float $y = 0.0,
public function __construct( public float $z = 0.0,
float $x = 0.0, ) {}
float $y = 0.0, }
float $z = 0.0
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}

 Tipos union
En lugar de anotaciones de PHPDoc para una combinación de tipos, puede usar declaraciones de tipos de unión nativos
que se validan en tiempo de ejecución.
class Number { class Number {
/** @var int|float */ public function __construct(
private $number; private int|float $number
) {}
/** }
* @param float|int $number new Number('NaN'); // TypeError
*/
public function __construct($number) {
$this->number = $number;
}
}

1
new Number('NaN'); // Ok

 Expresiones match
El nuevo partido es similar al cambio y tiene las siguientes características:
o Match es una expresión, lo que significa que su resultado puede almacenarse en una variable o devolverse.
o Las ramas de match solo admiten expresiones de una sola línea y no necesitan un enunciado break;
o match hace comparaciones estrictas.
switch (8.0) { echo match (8.0) {
case '8.0': '8.0' => "Oh no!",
$result = "Oh no!"; 8.0 => "This is what I expected",
break; };
case 8.0: //> This is what I expected
$result = "This is what I expected";
break;
}
echo $result;
//> Oh no!

 Operador nullsafe
En lugar de condiciones de verificación de null, ahora se puede usar una cadena de llamadas con el nuevo operador
nullsafe. Cuando falla la evaluación de un elemento en la cadena, la ejecución de toda la cadena aborta y toda la
cadena se evalúa como null.
$country = null; $country = $session?->user?->getAddress()?-
if ($session !== null) { >country;
$user = $session->user;

if ($user !== null) {

$address = $user->getAddress();

if ($address !== null) {

$country = $address->country;
}
}
}

 Comparación más sana de cadenas a números

Cuando se compara con una cadena numérica, PHP 8 usa una comparación de números. De lo contrario, convierte el
número en una cadena y utiliza una comparación de cadenas.
0 == 'foobar' // true 0 == 'foobar' // false

 Errores de tipo consistentes para funciones internas

La mayoría de las funciones internas ahora arrojan una excepción de error si falla la validación de los parámetros.
strlen([]); // Warning: strlen() expects strlen([]); // TypeError: strlen():
parameter 1 to be string, array given Argument #1 ($str) must be of type string,
array given
array_chunk([], -1); // Warning:
array_chunk(): Size parameter expected to array_chunk([], -1); // ValueError:
be greater than 0 array_chunk(): Argument #2 ($length) must
be greater than 0

 Compilación Just-In-Time
PHP 8 presenta dos motores de compilación JIT. Tracing JIT, el más prometedor de los dos, muestra un rendimiento
aproximadamente 3 veces mejor en las pruebas sintéticas y una mejora de 1.5 a 2 veces en algunas aplicaciones
específicas de ejecución prolongada. El rendimiento típico de la aplicación está a la par con PHP 7.4.
2
  Sistema de tipos y mejoras en el manejo de errores
o Comprobaciones de tipo más estrictas para operadores aritméticos/bit a bit.
o Validación de método de rasgo abstracto.
o Firmas correctas de métodos mágicos.
o Avisos de motor reclasificados.
o Error fatal para firmas de métodos incompatibles.
o El operador @ ya no silencia los errores fatales.
o Herencia con métodos privados.
o Tipo mixtos.
o Tipo de retorno estático.
o Tipos de funciones internas.
o Objetos opacos en lugar de recursos para Curl, Gd, Sockets, OpenSSL, XMLWriter y extensiones XML.

 Otros ajustes y mejoras de sintaxis

o Permitir una coma final en listas de parámetros y listas de uso de cierre.
o catches sin captura.
o Ajustes de sintaxis variable.
o Tratar los nombres del espacio de nombres como token único.
o Ahora throw es una expresión.
o Permitir ::class en objetos.

 Nuevas clases, interfaces y funciones

o Clase de mapa débil.
o Interfaz encadenable.
o str_contains(), str_starts_with(), str_ends_with().
o fdiv()
o get_debug_type().
o get_resource_id().
o Implantación del objeto token_get_all().
o Nuevas APIs de manipulación y cruce de DOM.