Tutoriel pour apprendre les nouveautés de PHP 7

L'utilisation des espaces de noms nous amène à effectuer de nombreuses déclarations. On va pouvoir maintenant les regrouper. Prenez, par exemple, ce code :

use App\Http\Controllers\Controller;
use App\Http\Requests\CommentRequest;
use App\Models\Post;
use App\Models\Comment;

On a autant de lignes que de déclarations. On va pouvoir simplifier ainsi :

use App\Http\{
    Controllers\Controller,
    Requests\CommentRequest
};
use App\Models\{
    Post,
    Comment
};

On y gagne en clarté !

II-A. Paramètres des fonctions▲

/**
 * Get the next comments for the specified post.
 *
 * @param  \App\Models\Post  $post
 * @param  integer $page
 * @return array
 */
public function comments(Post $post, $page)
{
    ...
}

public function comments(Post $post, int $page)

declare(strict_types = 1);

function action(iterable $elements)

function action(iterable $elements = [])

II-B. Type du retour▲

/**
 * Get .env element.
 *
 * @param string $key
 * @return string
 */
public function get($key)
{
    return $this->env->get ($key);
}

public function get($key) : string

III-A. L'opérateur de coalescence▲

$category = isset($request->category) ? $request->category : 'aucune';

$category = $request->category ?? 'aucune';

III-B. L'opérateur « spaceship »▲

usort($element, function ($a, $b) {
  return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
});

usort($element, function ($a, $b) {
  return $a <=> $b;
});

Avec PHP 5 on a hérité des fonctions anonymes qui sont, il faut l'avouer, bien pratiques surtout comme fonctions de rappel.

Avec PHP 7 ce sont maintenant les classes qui peuvent devenir anonymes. Autrement dit on n'a pas besoin de faire toutes les déclarations. Voici un exemple :

$maClasseAnonyme = new class($parametre) {
   private $parametre;
   public function __construct($parametre) {
     $this->parametre = $parametre;
   }
};

À part d'être anonymes, on les utilise exactement comme les autres : implémentation d'interfaces, héritages, traits.

J'avoue que je ne vais pas m'en servir tous les jours.

Si vous n'êtes pas familiarisé avec les générateurs alors, commencez par vous renseigner à leur sujet. C'est une façon de fournir des éléments d'un ensemble (itérateur) sans être obligé de construire au départ cet ensemble, donc de ne pas affecter outre mesure la mémoire.

Ce n'est pas clair ? Voici un exemple :

function entiers() {
    for ($i = 0; $i <= 10; ++$i) {
        yield $i;
    }
}

foreach (entiers() as $number) {
    echo "$number ";
}

// Résultat : 0 1 2 3 4 5 6 7 8 9 10

Oui c'est un peu idiot comme exemple, mais c'est pour le principe !

La délégation c'est le fait pour un générateur d'en appeler un autre :

function entiers() {
    for ($i = 0; $i <= 5; ++$i) {
        yield $i;
    }
}

function nombres() {
    yield 100;
    yield from entiers ();
    yield 101;
    yield from entiers ();
}

foreach (nombres() as $number) {
    echo "$number ";
}

// Résultat : 100 0 1 2 3 4 5 101 0 1 2 3 4 5

Bon ce n'est pas plus malin comme exemple, mais au moins ça donne le principe.

Les exceptions ont été apportées à PHP à partir de la version 5. Mais ça ne concerne que les objets et toutes les autres erreurs de PHP ne passent pas par là. D'autre part, il est en général fait usage d'un gestionnaire par défaut avec la fonction set_exception_handler.

PHP 7 apporte l'interface Throwable qui concerne les exceptions et, c'est nouveau, les erreurs, parce qu'elle se place en tête de la hiérarchie.

Prenons ce code :

function test($object)
{
  return $object->riendutout();
}
test(null);
echo 'Je marche encore !';

Si je l'exécute, je vais tomber immanquablement sur une erreur fatale : Call to a member function riendutout() on null…

On va maintenant intercepter cette erreur :

function test($object)
{
  return $object->riendutout();
}
try
{
  test(null);
} catch(Error $e)
{
  echo $e->getMessage(), PHP_EOL;
}
echo 'Je marche encore !';

À l'exécution (PHP 7), on obtient :

Call to a member function riendutout() on null
Je marche encore !

On peut ainsi tout intercepter, même les divisions par zéro !

Avec PHP on peut utiliser des variables de variables, même si ce n'est pas très indiqué parce que ça complique la lecture du code et on peut, en général, facilement s'en passer.

Regardez ce code :

$identite = ['nom' => 'Pierre'];
$Pierre = 'Paul';
echo $$identite['nom'];

Avec PHP 5 vous obtenez : Pierre.

Avec PHP 7 vous obtenez plein d'erreurs : Array to string conversion…

Que se passe-t-il ?

PHP 7 apporte la « syntaxe uniforme des variables », un truc qui couvait depuis quelques années avec pas mal d'opposition à cause du cassage du code antérieur. Mais finalement c'est passé dans cette version.

Normalement l'interprétation se fait de gauche à droite, donc on devrait commencer par $$identite, puis prendre l'offset. Mais PHP 5 ne fait pas ça, il commence par traiter $identite['nom']. Par contre comme PHP 7 va scrupuleusement de gauche à droite il y a un gros souci. Pour que ça fonctionne, on doit écrire ${$identite['nom']}. Et là maintenant ça fonctionne !

Ce changement n'est pas anodin si vous voulez migrer du code en PHP 7 !

On voit qu'il y a pas mal de nouveautés dans cette version, et je n'ai pas parlé des choses plus ou moins anodines que vous pouvez trouver dans le manuel.