Topette ! PHP 7.4 est sorti y’a pas très longtemps, y’a grosso modo deux semaines pour être tout à fait précis. Arrivent avec cette version quelques nouvelles fonctionnalités, plus ou moins intéressantes, et plus ou moins bien branlées. Petit passage en revue de tout ça.

Les exceptions dans __toString

Bon, c’est pas le plus sexy, et on s’en fout un peu, mais il est désormais possible de throw des exceptions dans la méthode magique __toString de vos classes, qui est appelée par exemple lorsque vous faites un echo sur un objet. Avant, c’était pas possible. Voilà. C’est tout. On s’en fout ? Un peu. Suivant.

Le typage des propriétés

Ah, ça c’est cool ! Pour rappel, le gros truc en plus qu’amenait la version 7 de notre langage favori, était le typage approfondi des méthodes, notamment. On pouvait donc spécifier le type de retour d’une méthode, qu’il soit natif ou non, et celui de ses paramètres également. Mais un gros manque subsistait, le typage des propriétés d’une classe. C’est désormais réparé. Enfin… presque.

On peut donc maintenant typer les propriétés en faisant comme ça :

1
2
3
4
class Truc
{
	protected int $x;
}

Ça crashera à chaque fois qu’on essaie d’assigner autre chose qu’un entier à $x. Par exemple, ça, ça crash :

1
2
3
4
class Truc
{
	protected int $x = 'truc';
}

Ça aussi :

1
2
3
4
class Truc
{
	protected int $x = '4';
}

Ça aussi :

1
2
3
4
5
6
7
8
9
class Truc
{
	protected int $x;
	public function __construct()
	{
		$this->x = 'truc';
	}
}

MAIS. Il y a un mais. Ça, ça va passer :

1
2
3
4
5
6
7
8
9
class Truc
{
	protected int $x;
	public function __construct()
	{
		$this->x = '4';
	}
}

Alors va savoir pourquoi c’est autorisé dans une méthode et pas en assignation directe, pourquoi la nature de typage hybride de PHP reprend le dessus à cette occasion, mais… c’est comme ça. Je trouve ça un peu triste pour être honnête. Truc cool toutefois, si c’est une string qui contient un entier, il sera casté en int. Donc tu peux quand même être sûr du type des propriétés de ta classe, quoi qu’il en soit.

Les arrow-functions

PHP 7.4 débarque également avec quelques emprunts au monde du JavaScript, comme les arrow-functions. Quelque chose qui s’écrit comme ça : fn(int $a) => $a * 2, à la place d’un function (int $a) { return $a * 2; }.
Plusieurs choses peuvent perturber quand on découvre la syntaxe, comme cette flèche bien grasse pour remplacer les accolades, ou encore l’absence de return.
Mais plusieurs choses peuvent également perturber quand on est un habitué de la syntaxe en JavaScript. D’abord, la nécessité d’écrire fn. C’est un peu chiant. Puis surtout, en JavaScript, quand le corps de la méthode est multiligne, on peut caler les accolades après la flèche, et y rajouter le return. En PHP, c’est un peu naze pour le moment, on est obligé de faire du one-liner pour pouvoir utiliser les arrow-functions.

Mais du coup, quand on a un one-liner, ça sert qu’à faire les kékés avec une nouvelle notation, ou ça a vraiment un intérêt ? Bah ça en a un, figure-toi. Notamment au niveau des callbacks qui peuvent être passées à des fonctions PHP, qui vivent dans leur propre scope, scope modifiable à l’aide du mot-clé use, ce qui rend le tout assez lourdingue.

Exemple, en PHP 7.3, on faisait des trucs méga chiants comme ça :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Truc
{
	/**
	 * @var int
	 */
	private $multiplier;
	public function multiplyArray(array $values): array
	{
		$multiplier = $this->multiplier; // lourdiiiiiiiiiiiiiiingue
		return array_map(function (int $value) use ($multiplier): int { // reloooooou
			return $value * $multiplier;
		}, $values);
	}
}

Eh ben, en PHP 7.4, ça se transforme en quelque chose d’un chouya plus sex :

1
2
3
4
5
6
7
8
9
class Truc
{
	private int $multiplier;
	public function multiplyArray(array $values): array
	{
		return array_map(fn(int $value): int => $value * $this->multiplier, $values);
	}
}

Et encore, on n’est pas encore au niveau de déclarer multiplyArray en arrow-function directement, mais ça ne saurait tarder, à mon humble avis.

Il manque des trucs, mais c’est un chouette début non ?

L’opérateur spread

On reste dans l’emprunt au JavaScript, avec l’opérateur spread. Bon, eux ils l’utilisent, concrètement parce qu’ils n’ont pas de Array.prototype.merge. Alors en PHP, y’en avait pas nativement besoin, car la fonction array_merge fait déjà bien le taf. Mais n’empêche, ils l’ont quand même fait. Et… assez mal, en plus. Très déçu par celui-là.

Bon, on va prendre un cas nominal, avec deux tableaux, où là, l’opérateur marche plutôt bien. Par exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$a = [1, 2, 3];
print_r([...$a, 5]);
/*
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
)
*/
print_r([5, ...$a]);
/*
Array
(
    [0] => 5
    [1] => 1
    [2] => 2
    [3] => 3
)
*/

Donc ça, c’est vraiment le comportement attendu. Mais quand on commence à bidouiller les clés, ça devient n’importe quoi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$a = [10 => 1, 20 => 2, 30 => 3];
print_r([...$a, 40 => 5]);
/*
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [40] => 5
)
*/
print_r([40 => 5, ...$a]);
/*
Array
(
    [40] => 5
    [41] => 1
    [42] => 2
    [43] => 3
)
*/

Bon là c’est n’importe quoi. On s’attend clairement à recevoir les clés 10, 20, 30 et 40, et à la place, ça dépile le tableau spreadé en ignorant complètement ses clés. Mais quid du tableau associatif avec des clés string alors ? Eh bien… c’est pire :(

1
2
3
4
5
6
7
$a = ['key1' => 10, 'key2' => 20];
print_r([...$a, 'key2' => 30]);
/*
Fatal error: Uncaught Error: Cannot unpack array with string keys
*/

Erf. C’est juste pas possible. C’est trop triste. Mais bon. array_merge existe, et a donc de beaux jours devant lui.

L’opérateur d’assignation null coalescent

Bon, je suis pas très sûr pour le nom. Mais un nouvel opérateur fait son arrivée dans le petit monde de PHP. En PHP 7, était arrivé l’opérateur null coalescent, qui s’utilisait comme suit :

1
$a = $b ?? $c ?? 'ok bah rien alors';

L’idée est de prendre, un peu à la manière de la fonction SQL COALESCE, la première valeur non nulle parmi $b, $c, ou la valeur par défaut qui suit.

Eh bien en PHP 7.4, se pointe un opérateur d’assignation à destination des tableaux, sur le même modèle.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
$a = [
	'name' => 'Mbaye NIANG',
	'email' => 'mbaye@staderennais.com'
];
$a['email'] ??= 'niang@staderennais.com';
print_r($a);
/*
Array
(
    [name] => Mbaye NIANG
    [email] => mbaye@staderennais.com
)
*/
$b = [
	'name' => 'Mbaye NIANG'
];
$b['email'] ??= 'niang@staderennais.com';
print_r($b);
/*
Array
(
    [name] => Mbaye NIANG
    [email] => niang@staderennais.com
)
*/

Vous l’aurez compris, il permet de s’abstraire d’un tas de isset pour donner des valeurs par défaut à un tableau. Bon, moi j’avais déjà tendance à utiliser array_merge (encore) pour ce genre d’usages, donc ça changera pas ma vie, mais c’est quand même bon à connaître.

__serialize et __unserialize

Bon, celui-là, je t’avoue, je vais jamais m’en servir. Déjà, je ne savais même pas qu’on pouvait appliquer serialize sur un objet. Donc, spoiler alert, on peut. Et grâce à PHP 7.4, et l’introduction des deux méthodes magiques __serialize et __unserialize, on peut customiser la sérialisation. Je vois pas tellement à quoi ça sert, mais… ok. Ça marche comme ça :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Truc
{
	private $theFirstProperty = 12;
	public function getFirstProperty(): int
	{
		return $this->theFirstProperty;
	}
	public function __serialize()
	{
		return [
			'a' => $this->theFirstProperty
		];
	}
	public function __unserialize(array $serialized)
	{
		$this->theFirstProperty = $serialized['a'];
	}
}
$t = new Truc();
echo serialize($t); // O:4:"Truc":1:{s:1:"a";i:12;}
echo unserialize(serialize($t))->getFirstProperty(); // 12

Conclusion

Bon, bah voilà, c’est à peu près tout. Je vais l’admettre tout de suite, j’ai juste retranscrit l’excellent tuto vidéo de Coder’s Tape, disponible ici.

J’espère que ça t’aura permis de découvrir des trucs cools, sinon, bah… tant pis. La bise :)