Découverte des nouvelles fonctionnalités de PHP7

En 2015, le monde PHP a avait vu sortie une nouvelle version majeure , PHP 7, 10 ans après la sortie de la dernière version majeure, PHP 5. Avec un grand pas en avant, PHP 7 introduit de nombreuses nouvelles fonctionnalités et mises à niveau .
Cependant, il supprime également les anciennes fonctionnalités obsolètes, ce qui introduit des ruptures de compatibilité, rendant plus difficile la migration des anciennes applications vers la nouvelle version. Dans cet articles, je vais vous présenter diverses fonctionnalités qu’apporte le PHP7.

Déclaration du type de retour ( Return Type Declarations )

Avec PHP7, nous avons maintenant la possibilité d’être un peu plus « précis » sur la façon dont nos fonctions et méthodes retourneront des valeurs tout en gardant une rétrocompatible avec les anciennes anotations. Vous n’avez pas besoin d’utiliser cette fonctionnalité mais je conseil vivement de le faire ne serait ce que pour définir proprement ce que vos fonctions sont censés retourner 🙂

<?php
function foo(a) : string {
    return a;
}

Dans notre exemple, nous indiquons que le type de retour de la fonction foo est une chaîne de caractères. Si vous essayez d’envoyer un nombre à la place d’une chaine de caractères, php ne va pas vous renvoyer une erreur mais convenir votre nombre en chaîne de caractères

<?php 
function foo(a) : string {
    return a;
}

foo(15);
?>

string(2) "15"

En revanche, si vous essayez de transmettre des objets ou un tableau, vous allez avoir le droit à une erreur de type TypeError qui va ressembler à sa :

> foo([15, 10]);
> Fatal error: Uncaught TypeError: Return value of foo() must be of the type string, array returned in <file>:5

Vous pouvez rendre la déclaration de vos types de fonctions en mode strict declare(strict_types = 1); ce qui aura pour effet d’interdire toute conversion, si on reprends notre exemple, foo(15) aura pour effet de renvoyer une erreur plutôt que la version chaîne de caractères de 15.

Déclaration types scalaires ( Scalar Type Declarations )

Sachez que, comme pour les déclarations de type retour, PHP tentera de convertir une valeur dans le type défini. Mais en déclarant declare(strict_types = 1); La déclaration de type strict arrêtera ce comportement et provoquera une erreur à la place!

function foo(int $number, string $name) : string {
    return $name." has ".$number;
}

Null Coalesce Operator

Avant PHP7, nous étions amener à faire ce genre de lines :

<?php

if (isset($foo)) {
    echo $foo;
} else {
    echo 'empty';
}

// ou bien

echo isset($foo) ? $foo : 'empty';

Dans PHP7, nous avons le Null Coalesce ?? Opérateur, qui ressemble à ceci :

echo $foo ?? 'empty';

Vous avez la possibilité de tester plusieurs variables également !

echo $foo ?? $deuxieme ?? $troisieme ??  "default";

Spaceship Operator

PHP 7 nous apporte également de nouveaux opérateurs. Le premier que nous allons explorer est l’opérateur spaceship-operator où l’opérateur vaisseau spacial en français 🙂 . Avec un nom comme ça, qui ne veut pas l’utiliser? L’opérateur de vaisseau spatial est un bon ajout au langage, complétant les opérateurs supérieurs et inférieurs.

< = >

L’opérateur de vaisseau spatial est mis en place en utilisant trois opérateurs individuels, inférieur à, égal et supérieur à. Essentiellement ce qu’il fait est de vérifier chaque opérateur individuellement. D’abord, moins que. Si la valeur à gauche est inférieure à la valeur à droite, l’opérateur de vaisseau spatial renverra -1. Si ce n’est pas le cas, il va tester si la valeur à gauche est égale à la valeur sur la droite. Si c’est le cas, il retournera 0. Sinon, il passera au test final. Si la valeur à gauche est plus que la valeur sur la droite. Alors, si les 2 autres ne sont pas passés, celui-ci doit être vrai. Et il retournera 1.

Throwables

Un grand changement dans PHP 7 est le fait que les erreurs ne sont plus retourné comme elles l’ont été. Les erreurs se comportent maintenant de la même manière que les exceptions. Ils héritent tous les deux de l’interface Throwable.

Cela signifie que les erreurs peuvent maintenant être interceptées dans un bloc try & catch. Vous pouvez capturer les exceptions et les erreurs en tant que Throwables, mais vous pouvez également détecter les erreurs en tant qu’objets Error.

Il existe différents types d’erreurs que nous pouvons détecter:

<?php
/**
 * Throwable interface
 */
//Error as Throwable
try {
    sqdf();
} catch (Throwable $t) {
    echo "Throwable: ".$t->getMessage().PHP_EOL;
}
//Exception as Throwable
try {
    throw new Exception("Bla");
} catch (Throwable $t) {
    echo "Throwable: ".$t->getMessage().PHP_EOL;
}
//Error
try {
    sqdf();
} catch (Error $e) {
    echo "Error: ".$e->getMessage().PHP_EOL;
} catch (Exception $e) {
    echo "Exception: ".$e->getMessage().PHP_EOL;
}
//Exception
try {
    throw new Exception("Bla");
} catch (Error $e) {
    echo "Error: ".$e->getMessage().PHP_EOL;
} catch (Exception $e) {
    echo "Exception: ".$e->getMessage().PHP_EOL;
}
//Type error
try {
    function add(int $a, int $b):int {
        return $a + $b;
    }
    echo add(array(), array());
} catch (TypeError $t) {
    echo "Type error: ".$t->getMessage().PHP_EOL;
}

···