PHP 5.6 est sortie !

PHP 5.6 a été publiée le 28 août, un peu plus d’un an après la sortie de PHP 5.5 – essayant ainsi de se conformer au planning de releases qui prévoit, depuis PHP 5.4 il y a deux ans, la sortie d’une version mineure par an.

Dans la suite logique de ce qui avait été fait pour PHP 5.4 et 5.5 il y a respectivement deux ans et un an, PHP 5.6 apporte plusieurs nouveautés destinées à faciliter la vie des développeurs travaillant avec le langage, en particulier au niveau de la syntaxe de celui-ci – sans toutefois révolutionner quoi que ce soit¹.

Je vais, au cours de cet article, passer en revue quelques-uns des points qui attirent mon attention vers cette toute nouvelle version.

Fonctions variadiques et unpacking d’arguments

Les deux éléments qui sont le plus souvent cités lorsque l’on parle des nouveautés introduites par PHP 5.6 vont de pair : il s’agit des fonctions variadiques et de l’unpacking d’arguments.

Une fonction variadique se déclare en utilisant le symbole ... avant le dernier nom de variable dans sa liste de paramètres :

function ma_fonction_variadique($a, $b, ... $params) {
    var_dump($a, $b, $params);
}

Elle s’appelle ensuite comme n’importe quelle fonction PHP, sans que l’appelant soit limité dans le nombre de paramètres qu’il peut passer :

ma_fonction_variadique(10, 20, 30, 40, 50);

La fonction recevra les deux paramètres qu’elle attendait – ici $a et $b – et tous ceux passés ensuite lors de l’appel se verront regroupés au sein du tableau $params. La sortie obtenue en exécutant cet exemple sera donc la suivante :

int(10)
int(20)
array(4) {
  [0] => int(30)
  [1] => int(40)
  [2] => int(50)
  [3] => int(60)
}

Inversement, l’unpacking de paramètres permet à un tableau de données d’être passé à une fonction sous forme de plusieurs paramètres. Par exemple, considérons la portion de code suivante :

function ma_fonction($a, $b, $c, $d) {
    var_dump($a, $b, $c, $d);
}

$tableau = [30, 40, 50, ];
ma_fonction(10, 20, ... $tableau);

Lors de son exécution, notre fonction ne recevra pas un ni deux paramètre(s), ni même cinq, mais quatre : le tableau spécifié en troisième position lors de l’appel sera découpé en plusieurs arguments, grâce à l’utilisation de l’opérateur ... (et la dernière valeur de ce tableau, 50, sera perdue puisqu’aucun paramètre du prototype de la fonction n’existe pour la recevoir).

Expressions scalaires pour les constantes

Même si l’évolution suivante semble plus mineure, je suis persuadé que c’est celle qui sera le plus rapidement et le plus largement utilisée² : PHP 5.6 permet d’utiliser des expressions pour les valeurs de constantes lors de leur déclaration – ou comme valeurs par défaut pour les paramètres de fonctions.

En effet, il est désormais possible d’utiliser des écritures de ce type :

class MaClasse {
    const CTE_01 = 1 << 4;
    const CTE_02 = "CTE_01 vaut " . self::CTE_01 * 1.5;
    
    public function method($a, $b = 15*60*10) {
        // ...
    }
}

var_dump(MaClasse::CTE_02);

Vous reconnaîtrez que pouvoir utiliser 1 << 4 et 15*60*10 améliore grandement la lisibilité de cette portion de code – et que pouvoir construire la seconde constante en concaténant une chaîne avec une autre constante est fort appréciable !

use functions et use const

La fonctionnalité d’espaces de noms introduite avec PHP 5.3 incluait un mot-clef use, qui permet de faire référence à une classe d’un autre espace de noms sans avoir à passer par son nom pleinement qualifié, ainsi que d’aliaser des classes.

PHP 5.6, par le biais de use function, permet d’effectuer la même manipulation pour des fonctions.

Par exemple, considérons un fichier autrenamespace.php contenant cette portion de code :

<?php
namespace autrenamespace;

function fonction_autrenamespace() {
    var_dump(__FUNCTION__);
}

Ce fichier et cette fonction peuvent désormais être utilisés depuis un autre fichier de la manière suivante :

<?php
namespace monnamespace;
require __DIR__ . '/autrenamespace.php';

use function \autrenamespace\fonction_autrenamespace;

fonction_autrenamespace();

Avant PHP 5.6 et sans disposer de use function, il aurait fallu utiliser, systématiquement, le nom pleinement qualifié de la fonction pour pouvoir l’appeler :

\autrenamespace\fonction_autrenamespace();

Suivant la même principe, use const a aussi été ajouté à PHP 5.6, pour répondre à cette problématique pour l’emploi de constantes.

Et plein d’autres améliorations !

Quelques autres évolutions, que je ne détaillerai pas réellement ici, font aussi leur arrivée avec PHP 5.6.

Un nouvel opérateur de puissance a été introduit : **. Je doute qu’il soit très souvent employé, mais il permettra de rendre certaines opérations plus lisibles que lorsque nous devions passer par la fonction pow().

Les extensions PHP ont désormais la possibilité de surcharger les opérateurs pour les classes qu’elles définissent. Ce principe est déjà utilisé par l’extension GMP, menant à une écriture beaucoup plus intuitive (par rapport à l’emploi de fonctions) des opérations réalisées avec des grands nombres. Notez que la surcharge d’opérateurs n’est pas rendue possible à l’espace utilisateur.

De nombreuses améliorations ont été apportées au niveau de SSL/TLS, visant à améliorer la sécurité des applications développées avec PHP (en particulier, lors de l’utilisation de paramètres par défaut – qui sont souvent ceux employés par les développeurs peu expérimentés en matière de sécurité). A ce sujet, vous pouvez lire la section Changements apportés à OpenSSL pour PHP 5.6 du manuel.

Et, pour finir :

• PHP 5.6 intègre le débogueur phpdbg – qui n’est pas encore supporté par les IDE les plus répandus, ce qui limite pour l’instant son utilité.
• L’encodage par défaut est défini par la directive default_charset qui vaut désormais par défaut UTF-8. Il est maintenant utilisé par les fonctions qui dépendent de l’encodage, comme htmlspecialchars().
• Un support asynchrone a été mis en place pour ext/pgsql.

Quelques risques potentiels ?

Cette nouvelle version mineure de PHP respecte assez bien le principe qui veut qu’une version mineure n’introduise pas – ou peu – de problème de compatibilité par rapport à la version précédente.

Toutefois, quelques points méritent qu’on leur prête attention – je pense en particulier à ceux-ci :

• La vérification de certificats SSL qui est activée par défaut posera probablement quelques problèmes, en particulier en environnement de développement où nous travaillons souvent avec des certificats auto-signés.
• Plusieurs fonctions mcrypt_*() échoueront si on leur spécifie des clefs ou IVs incorrects – ce qui est une très bonne chose en termes de sécurité, puisque cela force l’emploi de paramètres corrects (au lieu de se rabattre sur des valeurs peu sûres).
• Enfin, l’upload de fichiers avec curl en utilisant la syntaxe @fichier n’est désormais possible que si l’option CURLOPT_SAFE_UPLOAD est renseignée à false : il convient de préférer l’emploi de CURLFile.
• Les ressources GMP sont désormais des objets – elles ne doivent donc, en particulier, plus être validées à l’aide de is_resource().
• always_populate_raw_post_data génère désormais une erreur de niveau E_DEPRECATED et php://input devrait être utilisé au lieu de $HTTP_RAW_POST_DATA, qui sera supprimé dans le futur.

Plusieurs de ces points sont liés à des problématiques de sécurité – ce qui explique que ces changements aient été acceptés pour une version mineure.

Bien sûr, les différents éléments abordés au cours de cet article ne constituent pas une liste exhaustive et correspondent principalement à ce qui attire mon attention vers PHP 5.6. Avant d’attaquer une montée de version de votre côté, pensez à consulter le guide de migration de PHP 5.5 à 5.6 !

Comme pour PHP 5.5 l’an dernier, je suis content de voir une nouvelle version qui apporte plusieurs nouveautés intéressantes, sans qu’elle ne constitue pour autant une révolution qui rendrait son adoption difficile.

Je conclurai en disant que j’ai hâte de pouvoir réellement me pencher sur la migration PHP 5.5 → 5.6 de quelques unes de mes applications, j’espère sur les prochains mois !

Et vous, quand prévoyez-vous de passer à PHP 5.6 ?