Nouvelles syntaxes PHP – Fabien MAILLE

Sommaire

1 Fonction recevant un nombre indéterminé de paramètres d’un même type

2 Récupérer certains éléments d’un tableau avec la méthode list

3 Depuis PHP 7.4, disponibilité des arrow functions, aussi nommée short closures

4 Les Union Types

5 Passer de switch à match

6 Syntaxes raccourcies de comparaison

6.1 Spaceship operator

6.1.1 Comparaison d’objets

6.1.2 Fonctions de tri

Fonction recevant un nombre indéterminé de paramètres d’un même type

Avec un type simple :

function setEditable(string ...$contexts): void
{
  foreach($contexts as $context) {
    ...
  }
}

setEditable('intranet', 'extranet');

Avec un type plus complexe :

function archivePosts(Post ...$posts): void
{
  foreach($posts as $post) {
    $post->archive();
  }
}

// Ici, $posts un un tableau d'objets Post.
archivePosts($posts);

Cela permet d’éviter ce genre de code :

function archivePosts(array $posts): void
{
  foreach($posts as $post) {
    if ($post instanceof Post === false) {
      throw new InvalidArgumentException('Object of type Post expected.');
    }
    $post->archive();
  }
}

archivePosts($posts);

Récupérer certains éléments d’un tableau avec la méthode list

// Un tableau à plusieurs éléments :
$array = [1, 2, 3];

// Récupérer tous les éléments :
list($a, $b, $c) = $array;

// Ne récupérer que certains éléments :
list(, , $c) = $array;

// Récupérer certains élément dans un ordre différents :
$array = [
    'a' => 1,
    'b' => 2,
    'c' => 3,
];

list('c' => $c, 'a' => $a) = $array;

Depuis PHP 7.4, disponibilité des arrow functions, aussi nommée short closures

// Ceci :
array_map(function (User $user) { 
    return $user->id; 
}, $users)
  
// Peut désormais être écrit ainsi :
array_map(fn (User $user): int => $user->id, $users)

Limité à une seule instruction, qui est également le retour.
Le mot-clé use n’est pas nécessaire pour accéder au scope parent.
Le mot-clé $this est disponible.

Les Union Types

// Avant, on utilisait souvent le type de retour mixed comme ceci :
/**
 * @return array|bool
 */
public function getAll(): mixed;

// Depuis PHP 8, on dispose des Union Types :
public function getAll(): array|bool;

Passer de switch à match

// Depuis PHP 8, ceci :
switch ($input) {
  case 0:
    $result = 'hello';
    break;
  case '1':
  case '2':
  case '3':
    $result = 'world';
    break;
};

// Peut devenir ceci :
$result = match($input) {
    0 => "hello",
    '1', '2', '3' => "world",
};

Syntaxes raccourcies de comparaison

// Depuis avant PHP 5 déjà, ceci :
if ($condition) {
    $result = 'foo' 
} else {
    $result = 'bar'
}

// Devient ceci :
$result = $condition ? 'foo' : 'bar';

// Depuis PHP 5.3, ceci :
$result = $condition ? $condition : 'default';

// Devient ceci :
$result = $initial ?: 'default';

/**
 * PHP 7.3 apporte le null coalescing operator
 */

$undefined ?? 'fallback'; // 'fallback'

$unassigned;
$unassigned ?? 'fallback'; // 'fallback'

$assigned = 'foo';
$assigned ?? 'fallback'; // 'foo'

'' ?? 'fallback'; // ''
'foo' ?? 'fallback'; // 'foo'
'0' ?? 'fallback'; // '0'
0 ?? 'fallback'; // 0
false ?? 'fallback'; // false

/**
 * PHP 7.4 apporte le null coalescing assignment operator
 */

function (array $parameters = []) {
    // Ici, $parameters['property'] prendra la valeur "default"
    $parameters['property'] ??= 'default';
}

/**
 * PHP 8 apporte le null safe operator
 */

// Avant :
$startDate = $booking->getStartDate();
$dateAsString = $startDate ? $startDate->asDateTimeString() : null;

// Après :
$dateAsString = $startDate?->asDateTimeString;

// Avant :
$country =  null;
if ($session !== null) {
    $user = $session->user;
    if ($user !== null) {
        $address = $user->getAddress();
        if ($address !== null) {
            $country = $address->country;
        }
    }
}

// Après :
$country = $session?->user?->getAddress()?->country;

Spaceship operator

Cet opérateur de comparaison retourne toujours l’un des trois valeurs suivantes :

0 : Les 2 opérandes sont égales.
-1 : L’opérande de gauche plus grande.
1 : L’opérande de droite est plus grande.

// Exemple avec des numériques : 
1 <=> 2; // Retourne -1, car 2 est plus grand que 1.

// Exemple avec du texte :
'a' <=> 'z'; // Retourne -1

// Texte d'une casse différente :
'Z' <=> 'z'; // Retourne -1.
/**
 * Les minuscules sont considérées plus "grandes".
 * Explication : La comparaison de texte est faite caractère par caractère.
 * Dès qu'un caractère diffère, c'est sa valeur ASCII qui est comparée.
 * Or, les minuscules viennent après les majuscules dans la table ASCII.
 */

// Exemple avec des tableaux :
[2, 1] <=> [2, 1]; // Retourne 0

// Exemple avec des tableaux à plusieurs dimensions :
[2, 1] <=> [2, 1]; // Retourne 0
[[1, 2], [2, 2]] <=> [[1, 2], [1, 2]]; // Retourne 1

Comparaison d’objets

Les objets sont comparés chacun selon leur type, sachant que chaque objet peut définir sa manière d’être comparé. Sans quoi ils sont comparés selon leurs attributs et valeurs.

$dateA = DateTime::createFromFormat('Y-m-d', '2000-02-01');
$dateB = DateTime::createFromFormat('Y-m-d', '2000-01-01');
$dateA <=> $dateB; // Returns 1

Fonctions de tri

/**
 * Tri ascendant
 */

$array = [5, 1, 6, 3];

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

// Résultat :
// $array = [1, 3, 5, 6];

/**
 * Tri descendant
 */

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

// Résultat :
// $array = [6, 5, 3, 1];

Sources :
– Informations pour la plupart issues de https://stitcher.io