Repaso a las principales novedades que nos traen las versiones 7.4.X de PHP

Funciones flechas

Las “arrow functions” o “short closures” permite tener en una única linea de código una función corta, lo bueno es que se ahorra líneas de código, la parte mala es que hace algo menos legible el código.

$titles = array_map(function ($post) {
  return $posts->title();
}, $posts);

Con php 7.4 podremos hacerlo así:

$titles = array_map(fn($post) => $post->title(),$posts);

El mismo código en formato de tipado estricto sería:

$titles = array_map(fn(Post $post): string => $post->title(),$posts);

Si quieres recuperar valores por referencia se tiene que hacer de la siguiente manera:

fn&($x) => $x;

1

Typed properties

A partir de esta nueva versión podemos definir el tipo de atributos de las clases.

Class A
{
    public int $a;
    public ?string $b = 'foo';
    private Foo $prop;
    protected static string $static = 'default';
}

Se tiene que tener en cuenta que si intentamos usar un atributo de una clase sin inicializar la clase nos devuelve un nuevo error:

class Foo
{
    public int $bar;
}
$foo = new Foo;

var_dump($foo->bar);

Fatal error: Uncaught Error: Typed property Foo::$bar
must not be accessed before initialization

Se ha añadido un nuevo estado de las variables “uninitialized” Este es un listado de pos de variables:

• bool
• int
• float
• string
• array
• iterable
• object
• *? (nullable)
• self & parent
• Classes & interfaces

Con esta funcionalidad nos ahorraremos muchos métodos de tipo getter y setter que se usaban hasta ahora para definir el tipo de la variable.

class Car
{
    /**
     * Car Engine
     *
     * @var CarEngine
     */
    protected $engine

    /**
     * Returns the Engine instance
     *
     * @return CarEngine
     */
public function getEngine() : CarEngine
    {
        return $this->engine;
    }
    /**
     * Sets a Car Engine
     *
     * @param CarEngine $engine
     * @return void
     */
    public function setEngine(CarEngine $engine)
    {
        $this->engine = $engine;
    }
}

Improved type variance

Ahora podemos usar nuevos tipos de variables en el tipado:

class ParentType {}
class ChildType extends ParentType {}
class A {
    public function covariantReturnTypes(): ParentType
{ /* ... */ } }
class B extends A
{
    public function covariantReturnTypes(): ChildType
{ /* ... */ } }
/**
 * Contraviarants arguments
 */
class A {
    public function contraVariantArguments(ChildType $type)
{ /* ... */ } }
class B extends A
{
    public function contraVariantArguments(ParentType $type)
{ /* ... */ } }

Null coalescing assignment operator

En la versión de PHP 7.0 teníamos la novedad operador de fusión de NULL

$data['date'] = $data['date'] ?? new DateTime();

Con php 7.4 podemos hacer también:

$data['date'] ??= new DateTime();

2

Array spread operator

En php 7.4 podemos hacer:

$arrayA = [1, 2, 3];
$arrayB = [4, 5];
$result = [0, ...$arrayA, ...$arrayB, 6 ,7];
// [0, 1, 2, 3, 4, 5, 6, 7]

Con esta nueva funcionalidad podemos evitar el uso de la función array_merge. Tenemos que tener en cuenta que esta nueva funcionalidad solo funciona con arrays con indices numéricos, no funciona con diccionarios.

Numeric Literal Separator

PHP 7.4 permite usar “_” en números para separarlos visualmente, pero no afectan al valor real de los números, el motor de PHP simplemente los ignora.

$unformattedNumber = 107925284.88;
$formattedNumber = 107_925_284.88;