Explotando las mejoras de PHP en cada versión

Cada día falta menos para que se libere la nueva versión de PHP 7.4 (esperada para Diciembre del 2019) y, tal vez, todavía no estés utilizando las mejoras de sus versiones anteriores. Ya sea por desconocimiento o porque te da igual. Así que, en este artículo te voy a comentar las características más relevantes desde PHP 7.0 a PHP 7.3 para que empieces a utilizar en tus desarrollos y sacarle el máximo jugo a este lenguaje 😉.

Características de PHP 7.0

PHP 7.0 fue lanzado en Diciembre del 2015 y fue un gran salto desde su versión anterior. La característica más importante es que PHP 7.0 es hasta dos veces más rápido y consume menos memoria que PHP 5.6.

Mejor performance:

Disminución en el consumo de memoria:

PHP 7 no solo ha mejorado en velocidad y consumo de memoria. También se agregaron características que, nosotros como programadores, tenemos que tener en cuenta para sacarle el máximo provecho a PHP.

Soporte de Clases Anónimas en PHP 7.0

A partir de PHP 7.0 se agrego el soporte para las Clases Anónimas. Las clases anónimas son útiles cuando necesitas crear objetos simples que se utilizarán una única vez en la ejecución.

// Antes
class Logger
{
    public function log($msg)
    {
         echo $msg;
    }
}

$util->setLogger(new Logger());

// A partir de PHP 7.0
$util->setLogger(new class {
    public function log($msg)
    {
        echo $msg;
    }
});

Nuevo operador «??» para comparaciones nulas

Se ha agregado un nuevo operador que nos permite obtener el valor no nulo de una comparación. Por ejemplo:

$x = NULL;
$y = NULL;
$z = 3;
var_dump($x ?? $y ?? $z); // int(3)
 
$x = ["clave_c" => "mi_valor"];
var_dump($x["clave_a"] ?? $x["clave_b"] ?? $x["clave_c"]); // string(8) "mi_valor"

Operador «<=>» para comparaciones combinadas

El operador <=> devuelve 0 si ambos operandos son iguales, 1 si la izquierda es mayor y -1 si la derecha es mayor.

// Antes
function order_func($a, $b) {
    return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
}

// Ahora
function order_func($a, $b) {
    return $a <=> $b;
}

Declaración de tipos en funciones y métodos

En mi punto de vista, esta es una de las características más importantes que se agregaron en PHP 7.0. Nos permite definir que tipo de valor manejará y devolverá nuestra función o método. Por ejemplo:

function add(int $a, int $b): int {
    return $a + $b;
}

add(1, 2); // int(3)
add(1.5, 2); // int(3)

Declaración de tipo de dato devuelto

Este es una extensión de la característica anterior. Nos permite especificar que tipo de dato el método (o función) pueden devolver:

interface A {
    static function make(): A;
}
class B implements A {
    static function make(): A {
        return new B();
    }
}

Recomiendo mucho utilizar estas dos características porque estamos haciendo un código más seguro.

Agrupación de «use»

Por ultimo, voy a comentar la característica de reducir nuestro código agrupando los «use» de la siguiente forma:

// Antes:
use App\Model\Blog;
use App\Model\Post;
use App\Model\User;
use App\Model\CommentUser as Comment

// Ahora
use App\Model\{Blog, Post, User, Comment};

Pero estas no son las únicas características agregadas en PHP 7.0, como comente al inicio, esta nueva versión fue un gran salto y a continuación te dejo algunos enlaces mas de las características que no detalle:

Generador de delegación
Throwable Interface
Escapar unicade
Context Sensitive Lexer
Función dirname

Características de PHP 7.1

Avancemos a detallar las características que se agregaron en la versión PHP 7.1 para que comiences a utilizar.

Tipos Nullable

Anteriormente vimos que podemos definir que tipo de valor espera y devuelve el método o la función. Pero no estaba contemplado los valores null que es un tipo de dato en PHP que no es ni entero, ni cadena de carácter. Es por este motivo que se agrego el tipo Nullable para contemplar esta opción.

function answer(): ?int  {
    return null; //ok
}

function answer(): ?int  {
    return 42; // ok
}

function answer(): ?int {
    return new stdclass(); // error
}
function say(?string $msg) {
    if ($msg) {
        echo $msg;
    }
}

say('hola'); // ok -- imprime hola
say(null); // ok -- no se imprime
say(); // error -- falta parámetros
say(new stdclass); //error -- tipo incorrecto

Definición de devolución vacía

A diferencia de los tipos de devolución que detalle anteriormente que se aplican cuando se llama a la función, este tipo se verifica en tiempo de compilación, lo que significa que se produce un error sin que sea necesario llamar a la función. Veamos unos ejemplos y los errores que se mostrarían:

function lacks_return(): void {
    // valido
}

function returns_nothing(): void {
    return; // valido
}

function returns_one(): void {
    return 1; // Fatal error: A void function must not return a value
}

function returns_null(): void {
    return null; // Fatal error: A void function must not return a value
}

Pseudo tipo: Iterable

Otro «tipo de dato» que tenemos disponible, que solo sirve para especificar que un valor de un parámetro o un dato devuelto, es iterable.

function bar(): iterable {
    return [1, 2, 3];
}

function foo(iterable $iterable = []) {
    // ...
}

var_dump(is_iterable([1, 2, 3])); // bool(true)
var_dump(is_iterable(new ArrayIterator([1, 2, 3]))); // bool(true)
var_dump(is_iterable(1)); // bool(false)
var_dump(is_iterable(new stdClass())); // bool(false)

Asignación de matrices

A partir de PHP 7.1 tenemos una forma muy interesante de asignar valores de matrices a matrices, ¿cómo es esto?. Con el siguiente ejemplo lo vas a entender claramente.

$array = [1, 2, 3];
[$a, $b, $c] = $array; // Ahora $a será igual a 1, $b igual a 2 y $c igual a 3

// Lo mismo para este caso: $a = 1, $b = 2 y $c = 3
["a" => $a, "b" => $b, "c" => $c] = $array;

Capturar múltiples excepciones

Esta es una característica que me gusta bastante. Te permite definir más de una excepción por bloque.

// En vez de esto:
try {
   // (...)
} catch (ExceptionType1 $e) {
   // Código de tu excepción
} catch (ExceptionType2 $e) {
   // Código de tu excepción
} catch (Exception $e) {
   // (...)
}

// Podes hacer esto:
try {
   // (...)
} catch (ExceptionType1 | ExceptionType2 $e) {
   // Código de tu excepción
} catch (\Exception $e) {
   // ...
}

Más características de PHP 7.1

Visibilidad de constantes en clases
Closure de functiones callables

Características de PHP 7.2

Parámetro sin variación de tipo

Con las características agregadas en las versiones anteriores sobre la declaración de tipos de datos en los parámetros, abre el juego en PHP. Anteriormente, si definíamos un método especificando que su parámetro debía ser un arreglo:

class ArrayClass {
  public function foo(array $foo) { /* ... */ }
}

Y luego extendíamos esta clase sobrescribiendo el método sin especificar el tipo de dato:

class EverythingClass extends ArrayClass {
  public function foo($foo) { /* ... */ }
}

$thing = new EverythingClass();
$thing->foo(1);

Para este caso, el compilador nos arrojaba un Warning informando que el método foo() espera un arreglo. Por lo tanto, no se esta sobrescribiendo del todo el método.

En PHP 7.2, este warning se ha quitado y es totalmente posible el ejemplo anterior.

Comas al final de las listas

A partir de PHP 7.2 esta permitido poner una coma al final de cualquier tipo de listas:

// Grupo de namepaces
use Foo\Bar\{ Foo, Bar, Baz, };
 
// Arrays
$array = [1, 2, 3,];
 
// Argumentos en funciones o metodos (en la llamada)
fooCall($arg1, $arg2, $arg3,);

No es la característica mas llamativa, pero…bienvenida sea.

Más características de PHP 7.2

Debugging PDO Prepared Statement Emulation
Argon2 Password Hash
Contar objetos no «contables»

Características de PHP 7.3

Se agrega la función is_countable

En PHP 7.2, se había agregado un Warning cuando intentábamos contar cosas incontables. Por lo tanto, debíamos validarlo de la siguiente forma:

if (is_array($foo) || $foo instanceof Countable) {
    // Warning!
    return count($foo);
}

Con la versión de PHP 7.3 tenemos disponible la función is_countable() para tener un código más limpio:

if (is_countable($foo)) {
    // 👍
    return count($foo);
}

Se agregan funciones array_key_first() y array_key_last()

PHP 7.3 entiende que los arreglos son altamente utilizados y agregó dos funciones que nos hace la vida más fácil a nosotros como desarrolladores. Creo que el nombre de las funciones se explican por si mismas, pero igualmente les dejo un ejemplo:

$array = ["a" => 1, "b" => 2, "c" => 3]
echo array_key_first($array); // imprime "a"
echo array_key_last($array); // imprime "c"

Asignación por referencia en list()

Anteriormente, PHP no permitia asignar por referencia cuando utilizabamos la función list(). Esto no estaba permitido:

$array = [1, 2];
list($a, &$b) = $array;

Ahora, ya es posible realizarlo y hasta tenemos otra forma de hacerlo (gracias a la característica agregada en la versión 7.1):

[$a, &$b] = $array;

// También podemos hacer:
$array = [1, 2];
$a = $array[0];
$b =& $array[1];

Más características de PHP 7.3

JSON_THROW_ON_ERROR

Cookie «Mismo sitio»

Migración de PCRE a PCRE2

Deprecate and Remove Case-Insensitive Constants

Comparación de Performance entre versiones de PHP

A continuación, les dejo unas pruebas simples que se realizaron con las distintas versiones de PHP para que vean como ha ido cambiando la performance del lenguaje en cada versión.

PHP version : 5.6.40
--------------------------------------
test_math                 : 1.101 sec.
test_stringmanipulation   : 1.144 sec.
test_loops                : 1.736 sec.
test_ifelse               : 1.122 sec.
Mem: 429.4609375 kb Peak mem: 687.65625 kb
--------------------------------------
Total time:               : 5.103

PHP version : 7.0.33
--------------------------------------
test_math                 : 0.344 sec.
test_stringmanipulation   : 0.516 sec.
test_loops                : 0.477 sec.
test_ifelse               : 0.373 sec.
Mem: 421.0859375 kb Peak mem: 422.2109375 kb
--------------------------------------
Total time:               : 1.71

PHP version : 7.1.28
--------------------------------------
test_math                 : 0.389 sec.
test_stringmanipulation   : 0.514 sec.
test_loops                : 0.501 sec.
test_ifelse               : 0.464 sec.
Mem: 420.9375 kb Peak mem: 421.3828125 kb
--------------------------------------
Total time:               : 1.868

PHP version : 7.2.17
--------------------------------------
test_math                 : 0.264 sec.
test_stringmanipulation   : 0.391 sec.
test_loops                : 0.182 sec.
test_ifelse               : 0.252 sec.
Mem: 456.578125 kb Peak mem: 457.0234375 kb
--------------------------------------
Total time:               : 1.089

PHP version : 7.3.4
--------------------------------------
test_math                 : 0.233 sec.
test_stringmanipulation   : 0.317 sec.
test_loops                : 0.171 sec.
test_ifelse               : 0.263 sec.
Mem: 459.953125 kb Peak mem: 460.3984375 kb
--------------------------------------
Total time:               : 0.984

Conclusión

Hasta aquí las comparaciones y características de cada versión. Espero que les haya gustado el artículo y empiecen a implementar cada característica de las versiones de PHP que, seguramente, su aplicación mejorará. Cualquier duda, pueden revisar la documentación oficial. Nos vemos en la próxima.

Fuente: https://medium.com/@meskis/evolution-of-php-v5-6-to-v8-0-c3514ebb7f28

Mirá estos artículos

Instalando Laravel Octane y lo comparamos con NodeJs y Go

Refactorizando código aplicando Casos de Uso

Como dockerizar un proyecto Laravel y subirlo a Clouding.io