PHP 8.1 : Nouvelles fonctions et dépréciations (Dernière version)

La version PHP 8.1 est la nouvelle version de PHP publiée en novembre 2021. Cette version s’accompagne de nouvelles fonctionnalités, d’améliorations des performances et de changements qui ouvriront davantage de possibilités aux développeurs PHP pour travailler de manière efficace et plus créative.

Il existe plus de 20 nouvelles fonctionnalités, des tonnes de changements, et plusieurs dépréciations dans PHP 8.1. Cet article va les passer en revue et vous aider à passer en douceur de PHP 8.0 à PHP 8.1.

Nouvelles fonctionnalités et mises à niveau de PHP 8.1

Cette nouvelle version majeure de PHP introduit plus de 20 nouvelles fonctionnalités. Gardez à l’esprit qu’il peut y avoir des changements après la date de sortie qui peuvent allonger ou raccourcir cette liste.

Voici quelques-unes des nouvelles fonctionnalités de PHP 8.1.

Énumérations

PHP 8.1 supporte les énumérations, ou enum pour faire court. C’est un type de données énuméré qui consiste en un ensemble fixe de valeurs possibles.

La syntaxe utilise enum pour déclarer les énumérations, suivi de son nom défini par l’utilisateur. Ensuite, il est suivi de case pour déclarer les valeurs possibles. Les énumérations peuvent avoir un nombre quelconque de cas, de zéro à autant que nécessaire.

L’énumération RFC utilise des cartes à jouer standard pour expliquer son fonctionnement. Il y a quatre couleurs fixes – Pique, Cœur, Carreau et Trèfle. Vous pouvez énumérer ces couleurs avec enum en PHP :

enum Suit {
  case Spades;
  case Hearts;
  case Diamonds;
  case Clubs;
}

Maintenant, l’enum Suit a quatre valeurs possibles de couleurs de cartes. Vous pouvez utiliser une fonction et des types d’application lorsque vous acceptez ou renvoyez une valeur de couleur avec une syntaxe, par exemple, Suit::Clubs

function pick_card(Suit $suit) {}
pick_card(Suit::Spades);

Les énumérations peuvent également contenir une valeur facultative de type string ou int. C’est ce qu’on appelle une Enum adossée, et elle répond aux critères suivants :

• Déclarez le type scalaire, qu’il s’agisse de string ou de int, dans la déclaration Enum.
• Tous les cas ont des valeurs.
• Tous les cas contiennent le même type de scalaire, que ce soit string ou int.
• Chaque cas a une valeur unique.

Supposons que nous voulions attribuer un score aux costumes de l’exemple précédent. Nous pouvons utiliser cette syntaxe :

enum Suit: string {
  case Spades = ‘10’;
  case Hearts = ‘8’;
  case Diamonds = ‘5’;
  case Clubs = ‘3’;

Fibers

Cette nouvelle fonctionnalité introduit l’exécution simultanée dans la programmation PHP. Cependant, l’exécution simultanée en PHP ne signifie pas que les actions sont exécutées en même temps.

Par exemple, il y a un point où le code principal va démarrer une fibre. Le code à l’intérieur de la fibre sera exécuté séparément dans un thread différent.

De même, le programme principal ne peut pas suspendre ou terminer les fibres. Seul le code à l’intérieur de la fibre peut se suspendre et renvoyer des données au programme principal. Le programme principal, alors, peut continuer l’exécution de la fibre à partir du point de suspension.

Une pile complète d’un programme PHP avec des fibres peut être compliquée, mais voici un exemple simple d’utilisation des fibres dans un programme Echo :

$fiber = new Fiber(function(): void {
    echo "Hello from the Fiber\n";
    Fiber::suspend();
    echo "Welcome back to the Fiber\n";
});
echo "Starting the program\n";
$fiber->start();
echo "Taken control back\n";
echo "Resuming Fiber\n";
$fiber->resume();
echo "Program ends\n";

Fiber::suspend() est l’endroit où la fibre va suspendre son exécution. Ensuite, quand le code principal appelle la fibre à nouveau avec $fiber->resume(), la fibre commencera à partir du point de suspension. Par conséquent, elle renverra un écho de Bienvenue à la Fiber.

Voici à quoi devrait ressembler la sortie :

Starting the program
Hello from the Fiber
Taken control back
Resuming Fiber
Welcome back to the Fiber
Program ends

Type d’intersection pure

PHP 8.1 supporte les types d’intersection qui permettent de déclarer plusieurs types de classe pour une valeur. A première vue, cela ressemble aux types union qui ont été introduits en PHP 8.0. Cependant, il y a une différence significative.

Les types d’union permettent à la valeur de remplir n’importe lequel des types déclarés. Par exemple, si des chaînes et des entiers sont déclarés, la valeur peut être soit des chaînes, soit des entiers déclarés.

En revanche, les types d’intersection purs n’autorisent que les valeurs qui remplissent tous les types déclarés. C’est pourquoi les types d’intersection purs ne peuvent utiliser que des types de classe ou d’interface, car la plupart des types standard tels que les chaînes de caractères et les entiers ne peuvent pas être remplis simultanément.

Pour déclarer un type d’intersection pure en PHP 8.1, utilisez l’opérateur & (AND). Voici un exemple :

function count_and_iterate(Iterator&\Countable $value) {
    foreach($value as $val) {}
    count($value);
}

La valeur $value doit être un objet qui implémente les interfaces Iterator et Countable. Sinon, cela provoquera une erreur de type.

jamais Type de retour

Il y a un nouveau type “jamais de retour” en PHP 8.1. Quand un type ” jamais de retour ” est déclaré dans une fonction, celle-ci ne retournera pas de valeur. La fonction doit également se terminer par une instruction de sortie, explicitement ou implicitement.

Voici un exemple d’une fonction simple avec le type jamais de retour :

function redirect(string $url): never {
    header('Location: ' . $url);
    exit();
}

Lorsque vous utilisez un type ” jamais de retour “, le reste du code du programme ne sera pas exécuté et ne retournera aucune valeur. Dans la pratique, le type ” jamais de retour ” est utile pour indiquer que la fonction n’exécutera pas le reste du code et se terminera ou sera lancée.

D’une certaine manière, le type jamais de retour est similaire au type void de retour. Toutefois, le type void return poursuit l’exécution après la fonction.

Type array_is_list

La nouvelle fonction array_is_list de PHP 8.1 vous aide à voir si un tableau contient des entrées qui sont une liste. Elle vérifiera les clés du tableau – si elles sont en ordre séquentiel, commencent à zéro, n’ont pas d’espace, et sont toutes des entiers, elle retournera vrai. Il retournera également vrai par défaut pour les tableaux vides.

Par exemple, la fonction array_is_list suivante retournera vrai :

array_is_list([]);
array_is_list([1, 2, 3]);
array_is_list([‘rock’, 2, 3]);
array_is_list([‘rock’, scissor]);
array_is_list([0 => 'rock', 'scissor']);
array_is_list([0 => 'rock', 1 => 'scissor']);

A l’inverse, voici des exemples de fonctions array_is_list fausses :

array_is_list([1 => 'rock', 'scissor']); // faux, ne commence pas par 0
array_is_list([1 => 'rock', 0 => 'scissor']); // faux, pas en ordre
array_is_list([0 => 'rock', 'suit' => 'paper']); faux, clés non entières
array_is_list([0 => 'rock', 2 => 'paper']); faux, non séquentiel

Attribut #[ReturnTypeWillChange]

Ce nouvel attribut indique qu’un type de retour provisoire non concordant ne devrait pas entraîner une notification de dépréciation. Avant PHP 8.0, la syntaxe des attributs était analysée comme un commentaire de code afin de ne pas provoquer d’erreur de syntaxe.

L’ajout de l’attribut #[ReturnTypeWillChange] à une méthode de classe dans la version PHP 8.1 ne posera aucun problème – il empêchera seulement la notification de dépréciation.

Voici un exemple de #[ReturnTypeWillChange] dans un code PHP :

class Sample implements ArrayAccess {
    #[\ReturnTypeWillChange]
    public function offsetGet(mixed $offset) {}
    // ...
}

Notez que cet attribut n’aura plus d’effet lorsque les types de retour provisoires seront transformés en types de retour standard.

readonly Propriétés

readonly est une nouvelle propriété de classe en PHP 8.1 et ne peut être initialisée qu’une seule fois depuis la classe où elle est déclarée. Toute classe ayant cette propriété ne sera pas modifiable et provoquera une erreur si vous la forcez à changer sa valeur.

Voici un exemple de la façon dont on déclare une propriété readonly dans une classe :

Maintenant, puisque le readonly a déjà été initialisé, vous ne pouvez pas modifier le $authid dans le code.

Si vous essayez de saisir une ligne comme celle-ci :

$author->authid = 15

Il en résultera cette erreur :

Error: Cannot modify readonly property User::$uid in ...:..

Fonctions fsync() et fdatasync()

fsync() et fdatasync() sont de nouveaux ajouts aux fonctions du système de fichiers en PHP 8.1. Elles ont des similarités avec fflush(), qui est utilisé pour vider les tampons vers le système d’exploitation. Cependant, fsync() et fdatasync() vident le tampon vers le stockage physique.

La principale différence entre elles est que la fonction fsync() inclut les métadonnées lors de la synchronisation des modifications des fichiers, alors que la fonction fdatasync() ne le fait pas.

Voici un exemple de la fonction fsync() dans un code :

$file = 'sample.txt';
$test = fopen($file, 'h');
fwrite($test, 'sample data');
fwrite($test, "\r\n");
fwrite($test, 'another data');
fsync($test);
fclose($test);

Vous pouvez utiliser soit fsync() soit fdatasync() à la ligne 6. Lorsque la fonction est appelée, il est demandé au système d’exploitation de vider les données dans la mémoire.

Ces fonctions sont utiles lorsque le programme a besoin d’un stockage cohérent des données. De plus, elles permettent de récupérer les données en cas de panne de l’application ou de défaillance du système.

Fonctions du sodium XChaCha20

Sodium est une extension PHP qui contient une bibliothèque cryptographique. Elle supporte l’algorithme de cryptage XChaCha20, un algorithme de chiffrement par flux qui est une variante de ChaCha20.

En PHP 8.1, trois nouvelles fonctions vous permettent de crypter et décrypter des données en utilisant XChaCha20 sans authentification. Cette méthode est appelée mode détaché, et les fonctions sont les suivantes :

• sodium_crypto_stream_xchacha20sodium_crypto_stream_xchacha20_keygen – génère une clé aléatoire à utiliser avec la fonction sodium_crypto_stream_xchacha20.
• sodium_crypto_stream_xchacha20 – génère un flux de clés d’octets pseudo-aléatoires en développant le nonce cryptographique et la clé générée précédemment.
• sodium_crypto_stream_xchacha20_xor – crypte un message en utilisant un nonce et une clé sécurisée sans authentification.

Outre les nouvelles fonctions, deux nouvelles constantes PHP sont définies dans l’espace de noms global :

• SODIUM_CRYPTO_STREAM_XCHACHA20_KEYBITES, affecté 32.
• SODIUM_CRYPTO_STREAM_XCHACHA20_NONCEBYTES, affecté 24.

nouveau dans Initialisateurs

PHP 8.1 permet maintenant d’utiliser de nouvelles expressions pour initialiser une valeur dans une déclaration de fonction.

En utilisant PHP 8.0, nous devons initialiser la valeur d’un paramètre optionnel en dehors du constructeur. Bien que cela fonctionne très bien, cela rend le code un peu plus long. Voici un exemple tiré du nouveau RFC :

class Test {
    private Logger $logger;
    public function __construct(
        ?Logger $logger = null,
    ) {
        $this->logger = $logger ?? new NullLogger;
    }
}

En PHP 8.1, nous pouvons simplement l’écrire comme ceci :

class Test {
    public function __construct(
        private Logger $logger = new NullLogger,
    ) {}
}

Prise en charge du déballage de tableaux à clé de caractères

La version précédente de PHP a ajouté le support de l’opérateur d’étalement de tableau (…). Il fonctionne pour le dépaquetage des tableaux et comme alternative à la fonction array_merge().

Toutefois, l’opérateur d’étalement ne prenait en charge que les touches numériques. L’utilisation de l’opérateur ou de la fonction pour les tableaux de chaînes de caractères entraînerait une erreur.

PHP 8.1 supporte maintenant le déballage des tableaux pour les tableaux à clés. Supposons que vous ayez ces tableaux :

$array_1 = ['a', 'b'];
$array_2 = ['c', 'd'];

Vous pouvez décompresser les clés du tableau en utilisant l’opérateur d’étalement.

$array = [...$array1, ...$array2];
var_dump($array);
//['a', 'b', 'c', 'd'];

Ou bien, décompressez les clés du tableau en utilisant la fonction array_merge() :

$array = array_merge($array1, $array2);
var_dump($array);
//['a', 'b', 'c', 'd'];

Syntaxe appelable de première classe

PHP 8.1 introduit une nouvelle syntaxe de callable de première classe pour créer un callable à l’intérieur de la portée courante.

Avant PHP 8.1, la syntaxe d’un appelable utilise Closure::fromCallable, comme ceci :

$callable = Closure:: fromCallable(‘hostinger’);

Grâce à la nouvelle syntaxe, vous pouvez utiliser (…) après l’objet au lieu d’utiliser Closure::from Callable. Cela facilite la création d’un callable de première classe. Voici un exemple de la fonction ci-dessus utilisant la nouvelle syntaxe :

Nouvelle classe IntlDatePatternGenerator

Dans la version précédente de PHP, vous pouvez créer une date et une heure localisées uniquement avec le format prédéfini IntlDateFormatter. Il y a huit formats prédéfinis – quatre formats de base et quatre variantes relatives qui utilisent hier, aujourd’hui et demain.

Bien que ces options soient raisonnables, elles ne sont pas aussi personnalisables qu’en PHP 8.1.

La nouvelle classe IntlDatePatternGenerator vous permet de spécifier le format d’une date, d’un mois et d’une heure. L’ordre exact peut être laissé au formateur.

Voici un exemple de son utilisation tiré de la RFC IntlDatePatternGenerator :

$skeleton = "YYYYMMdd";
 
$today = \DateTimeImmutable::createFromFormat('Y-m-d', '2021-04-24');
 
$dtpg = new \IntlDatePatternGenerator("de_DE");
$pattern = $dtpg->getBestPattern($skeleton);
echo "de: ", \IntlDateFormatter::formatObject($today, $pattern, "de_DE"), "\n";
 
$dtpg = new \IntlDatePatternGenerator("en_US");
$pattern = $dtpg->getBestPattern($skeleton), "\n";
echo "en: ", \IntlDateFormatter::formatObject($today, $pattern, "en_US"), "\n";
 
/*
de: 24.04.2021
en: 04/24/2021
*/

La variable squelette spécifie le format de date et d’heure YYYYMMDD, tandis que le formateur spécifie l’ordre final. Dans le code ci-dessus, nous obtenons deux résultats différents du formateur. Cependant, la date utilise toujours le format YYYYMMDD.

final Class Constants

Déclarer le nouveau drapeau final sur les constantes de classe les empêche d’être surchargées ou étendues par des sous-classes.

Si vous essayez d’étendre ou de remplacer une classe final, une erreur fatale se produira. Voici un exemple :

class First {
    final public const TEST = '1';
}
class Second extends First {
    public const TEST = '2';
}

Il en résultera :

Fatal error: Second::TEST cannot override final constant First::TEST in %s on line %d

Cet indicateur ne peut pas être utilisé pour une constante private car elle ne peut pas être accédée en dehors de la classe. Déclarer à la fois les constantes final et private entraînera une erreur fatale.

class First {
    final private const TEST = '1';
Fatal error: Private constant First::TEST cannot be final as it is never overridden in ... on line ...

Notation explicite des chiffres octaux

PHP supporte plusieurs systèmes numériques, comme le décimal par défaut (base 10), le binaire (base 2), l’octal (base 8) et l’hexa (base 16). Cependant, les systèmes numériques autres que le décimal doivent utiliser les préfixes suivants :

• Hexa – 0x
• Binaire – 0b
• Octal – 0

PHP 8.1 introduit les préfixes o (minuscule) et O (majuscule) pour les chiffres octaux. Cela signifie que les chiffres octaux sont maintenant plus apparents et plus lisibles.

Regardez ces exemples :

echo 77; // 77, numeric string
echo 077; // 63, old-format octal numeral
echo 0o77; // 63, octal numeral in PHP 8.1

Notez que ce nouveau préfixe est juste un ajout. Le préfixe 0 existant fonctionnera de la même manière en PHP 8.1.

Valeur full_path de $_Files pour les téléchargements de répertoires

$_FILES est une super variable globale contenant les noms, tailles, et types MIME des fichiers téléchargés.

Dans la version antérieure de PHP 8.1, $_FILES ne stockait pas les chemins relatifs ou le répertoire exact sur le serveur. Par conséquent, vous ne pouviez pas télécharger un répertoire entier avec un formulaire HTML de téléchargement de fichiers.

La nouvelle clé full_path résout le problème. Elle stocke les chemins relatifs et reconstruit la structure exacte du répertoire sur le serveur, ce qui rend possible le téléchargement de répertoires.

var_dump($_FILES);
array(1) {
  ["myupload"]=> array(6) {
    ["name"]=> array(2) {
      [0]=> string(8) "file.txt"
      [1]=> string(8) "file.txt"
    }
    ["full_path"]=> array(2) {
      [0]=> string(19) "foo/test1/file.txt"
      [1]=> string(19) "foo/test2/file.txt"
    }
    ["tmp_name"]=> array(2) {
      [0]=> string(14) "/tmp/phpV1J3EM"
      [1]=> string(14) "/tmp/phpzBmAkT"
    }
    // ... + error, type, size
  }
}

Dans l’exemple ci-dessus, il y a deux file.txt différents, mais ils sont stockés dans des répertoires différents. Si vous utilisez le tableau $_FILES["myupload"]["name"], il y aura des entrées en double, car les deux fichiers sont spécifiés avec le même nom.

Cependant, le tableau $_FILES["myupload"]["full_path"] contient le chemin d’accès de chaque fichier. Cela évite la duplication qui se produit dans le tableau précédent.

Encodage Lossless WebP et prise en charge de GdImage

En PHP 8.1, il y a un nouveau support du codage WebP lossless pour l’objet GdImage. Il peut être activé en utilisant l’extension GD et la version 0.2.0 de libwebp.

La nouvelle constante PHP pour déclarer le codage WebP lossless est IMG_WEBP_LOSSLESS, avec la fonction imagewebp. Dans un code PHP, cela ressemble à ceci :

$image = imagecreatefromjpeg('image.jpg');
imagewebp($image, 'image.webp', IMG_WEBP_LOSSLESS);

Support des images AVIF

En plus du support de WebP, PHP 8.1 – en utilisant l’extension GD, supporte également le format d’image AVIF. C’est un format d’image relativement nouveau, basé sur le format vidéo AV1. Il offre une meilleure compression et est libre de droits.

Afin d’ajouter le support des images AVIF au traitement des images PHP, vous devez compiler l’extension GD avec le support AVIF. Vous aurez également besoin de la version 0.8.2 ou supérieure de libavid pour l’extension GD.

En fonction de votre système d’exploitation, exécutez les commandes suivantes :

• Ubuntu/Debian – apt install libavif-dev
• RHEL/Fedora – dnf install libavif-devel

L’étape suivante consiste à utiliser l’option --with-avif flag avec le script ./configure pour compiler PHP avec le support AVIF.

./buildconf --force
./configure --enable-gd --with-avif

Ensuite, exécutez la commande suivante pour vérifier si le support AVIF est maintenant activé :

php -i | grep AVIF
If it’s enabled, you should see this output:
AVIF Support => enabled

Prise en charge de DNS-over-HTTPS

DNS-over-HTTPS augmente la confidentialité et la sécurité en exécutant la résolution DNS via le protocole HTTPS. Il crypte les données envoyées par l’ordinateur client au résolveur DNS.

L’extension Curl de PHP 8.1 permet maintenant de spécifier un serveur pour le protocole DNS-over-HTTPS. Pour utiliser cette nouvelle fonctionnalité, vous devez compiler PHP avec libcurl 7.62 ou plus. Cela dit, la plupart des systèmes d’exploitation utilisent déjà Curl 7.68, donc cela ne devrait pas être un problème.

Pour spécifier le DNS-over-HTTPS, utilisez l’option CURLOPT_DOH_URL.

$ch = curl_init('https://website.com');
curl_setopt($ch, CURLOPT_DOH_URL, 'https://dns.google/dns-query');
curl_exec($ch);

Notez que l’URL du serveur doit être une URL HTTPS, et qu’elle sera validée lors de l’exécution de la demande. La demande échouera si l’URL du serveur DNS n’est pas valide ou ne fournit pas de réponse valide.

Nous avons utilisé le serveur DNS public de Google dans l’exemple ci-dessus, mais vous pouvez également choisir n’importe quel autre serveur DNS-over-HTTPS public.

Classe CurlStringFile

L’extension Curl comporte une nouvelle classe CURLStringFile qui fonctionne de manière similaire à la classe CURLFile pour les téléchargements de fichiers. Toutefois, la classe CURLFile n’accepte qu’une URI ou un chemin d’accès au fichier, tandis que CURLStringFile accepte le contenu du fichier au lieu d’un chemin d’accès ou d’une URI.

Grâce à la nouvelle classe PHP 8.1, il est plus facile de créer une requête de téléchargement de fichier en utilisant des données stockées en mémoire. Par exemple, utilisez-la pour télécharger une image traitée en PHP ou stockée dans une variable PHP.

Voici un exemple d’utilisation du CURLStringFile dans un code PHP :

$txt = 'test content';
$txt_curlfile = new \CURLStringFile($txt, 'text/plain', 'test.txt');
$ch = curl_init('http://website.com/upload.php');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, ['file' => $txt_curlfile]);
curl_exec($ch);

Support des algorithmes pour les hachages MurmurHash3 et xxHash

PHP 8.1 introduit le support de deux algorithmes de hachage non-cryptographiques – MurmurHash3 et xxHash. Les hachages non cryptographiques sont plus rapides que la plupart des algorithmes de hachage actuels de PHP, tout en offrant une grande dispersion et un caractère aléatoire.

MurmurHash3

Pour MurmurHash3, voici les variantes supportées :

• murmur3a – 32-bit hash
• murmur3c – 128-bit hash sur architecture x86
• murmur3f – 128-bit hash sur architecture x64

Pour hacher une chaîne de caractères en utilisant MurmurHash3, utilisez une syntaxe comme celle-ci :

hash(‘murmur3a’, ‘hash_example’);
hash(‘murmur3c’, ‘hash_example’);
hash(‘murmur3f’, ‘hash_example’);

Vous pouvez mettre à jour les valeurs en séquence sans hacher la chaîne d’entrée dans son ensemble. C’est ce qu’on appelle le streaming hash.

$context = hash_init(‘murmur3a’);
hash_update($context, 'hash');
hash_update($context, '_');
hash_update($context, ‘example');
$hash = hash_final($context);

xxHash

PHP 8.1 supporte l’algorithme xxHash suivant :

• xxh32 – Sortie de hach 32-bit
• xxh64 – Sortie de hach 64-bit
• xxh3 – Sortie de hach 64-bit
• xxh128 – Sortie de hach 128-bit

Voici la syntaxe pour hacher une chaîne de caractères à l’aide de xxHash :

hash(‘xxh32’, ‘hash_example’);
hash(‘xxh64’, ‘hash_example’);
hash(‘xxh3’, ‘hash_example’);
hash(‘xxh128’, ‘hash_example’);

Semblable à MurmurHash3, xxHash est également un streaming hash qui vous permet de mettre à jour les valeurs en séquence.

$context = hash_init(‘xxh32’);
hash_update($context, 'hash');
hash_update($context, '_');
hash_update($context, ‘example');
$hash = hash_final($context);

Amélioration des performances

PHP 8.1 ajoute une nouvelle fonctionnalité pour supprimer la surcharge de l’héritage des classes, le cache d’héritage.

Précédemment, l’opcache compilait et mettait en cache les classes PHP séparément. Ensuite, il liait ces classes à l’exécution lors de chaque requête.

Le processus de liaison nécessite des contrôles de compatibilité et l’emprunt de méthodes, de propriétés ou de constantes aux classes et traits parents. Cela ralentit l’exécution, bien que le résultat soit le même pour chaque requête.

Le nouveau cache d’héritage résout ce problème en liant toutes les classes dépendantes uniques et en les enregistrant dans la mémoire mutualisée de l’opcache. Ce patch supprime également les limitations pour les classes immuables – toutes les classes stockées dans l’opcache sont maintenant immuables.

Cela se traduit par une diminution du nombre d’instructions pour chaque requête et une amélioration de 8 % pour l’application Symfony “Hello, World !“.

Constante MySQL_I_REFRESH_Replica

MySQLi introduit une nouvelle constante pour PHP 8.1 appelée MYSQLI_REFRESH_REPLICA. Cette constante a la même fonctionnalité que la constante existante MYSQLI_REFRESH_SLAVE.

Le nouveau nom répond à l’insensibilité raciale concernant la terminologie d’esclave. Cependant, la constante existante MYSQLI_REFRESH_SLAVE ne sera pas supprimée ou dépréciée en PHP 8.1.

Changements dans PHP 8.1

PHP 8.1 introduit quelques changements dans la syntaxe et les fonctionnalités. La plupart d’entre eux ne modifient pas de manière significative les fonctionnalités existantes, mais vous devez être conscient de ces changements si vous continuez à utiliser une application PHP existante sur PHP 8.1.

Les fonctions de codage/décodage HTML convertissent les guillemets simples et les substituent par défaut

PHP 8.1 apporte des modifications aux fonctions qui décodent et encodent les entités HTML. L’entité HTML est une représentation textuelle d’un caractère dans le code HTML. Des exemples courants d’entités HTML sont les caractères < et > qui composent les balises HTML telles que <h1> ou <b>

Le navigateur interprétera ces caractères comme du code HTML si vous les utilisez dans un document HTML. Par conséquent, si vous voulez que le navigateur les affiche dans leur forme originale, vous devez utiliser leurs entités HTML.

Par exemple, vous voulez que le navigateur rende
comme un texte. Vous l’écrivez donc dans le document HTML sous la forme 1&gt. &lt ; et &gt ; représentent respectivement < et >.

PHP possède quelques fonctions pour convertir les caractères HTML en entités HTML :

• htmlspecialchars – convertit les caractères spéciaux en entités HTML.
• htmlspecialchars_decode – convertit les entités HTML en caractères spéciaux.
• htmlentities – convertit les caractères applicables en entités HTML
• html_entitity_decode – convertit les entités HTML en leurs caractères apparentés.
• get_html_translation_table – renvoie la table de traduction pour les fonctions htmlspecialchars et htmlentities.

Dans les versions précédentes de PHP, ces fonctions ne convertissaient pas les guillemets simples (‘) et retournaient une chaîne vide. Cela a changé en PHP 8.1, car elles convertissent maintenant les guillemets simples en leur entité HTML, &apos ;.

Le changement s’effectue en remplaçant la signature ENT_COMPAT dans les fonctions par ENT_QUOTES | ENT_SUBSTITUTE. Voici la nouvelle syntaxe :

• htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE);
• htmlspecialchars_decode($string, ENT_QUOTES | ENT_SUBSTITUTE);
• htmlentities($string, ENT_QUOTES | ENT_SUBSTITUTE);
• html_entity_decode($string, ENT_QUOTES | ENT_SUBSTITUTE);
• get_html_translation_table(HTML_SPECIALCHARS, ENT_QUOTES | ENT_SUBSTITUTE);

Le shell interactif nécessite l’extension Readline

Dans les versions précédentes de PHP, il est possible d’ouvrir le shell interactif avec l’option php -a. Cependant, les fonctionnalités interactives n’étaient pas activées car elles nécessitent l’extension readline.

Par conséquent, l’option php -a n’avait aucun sens et revenait à ouvrir un shell non interactif à l’aide de la commande php.

Ce problème est maintenant corrigé dans PHP 8.1. L’utilisation de l’option php -a dans la ligne de commande sans l’extension readline activée retournera un message d’erreur.

php -a
Interactive shell (-a) requires the readline extension.

Cependant, si vous avez activé l’extension, elle ouvrira le shell interactif.

php -a
Interactive shell
php >
php > echo "Hello";
Hello
php > function test() {
php { echo "Hello";
php { }
php > test();
Hello

Le mode d’erreur par défaut de MySQLi est réglé sur Exceptions

Avant PHP 8.1, le traitement par défaut des erreurs de MySQLi était de les réduire au silence. Les développeurs devaient définir leurs fonctions de gestion des erreurs, ou le code ne suivait pas la gestion stricte des erreurs.

En PHP 8.1, la gestion des erreurs par défaut est définie pour lancer une exception.

MYSQLI_REPORT_ERROR|MYSQLI_REPORT_STRICT

Il s’agit d’un changement de rupture et, comme la valeur est différente, cela causera un problème de compatibilité. Toutefois, vous pouvez résoudre ce problème en définissant explicitement la gestion des erreurs à l’aide de la fonction MYSQLI_REPORT avant d’établir la première connexion MySQLi.

mysqli_report(MYSQLI_REPORT_ERROR|MYSQLI_REPORT_STRICT);

Fin de ligne personnalisable pour les fonctions d’écriture CSV

Dans les versions précédentes de PHP, les fonctions fputcsv() et SplFileObject::fputcsv sont codées en dur avec le caractère de fin de ligne “\n“. PHP 8.1 introduit une nouvelle fonction eol qui permet de personnaliser les caractères de fin de ligne.

Toutefois, ce paramètre est optionnel, et la fonction utilisera toujours “\n” par défaut. Si vous avez un code ou une application existante qui ne définit pas explicitement un caractère de fin de ligne, il utilisera toujours “\n“.

Si vous souhaitez utiliser le paramètre eol pour un caractère de fin de ligne personnalisé, voici un exemple de syntaxe :

function fputcsv($stream, array $fields, string $separator = ",", string $enclosure = "\"", string $escape = "\\", string  $eol = "\n"): int|false {}
public function fputcsv(array $fields, string $separator = ",", string $enclosure = "\"", string $escape = "\\", string  $eol = "\n") {}

Notez que vous devez utiliser des guillemets doubles avec les caractères de fin de ligne tels que \r, \n, ou \r\n afin qu’ils soient interprétés correctement.

Fonction compacte Appels d’alerte

La fonction compacte est utile pour créer un tableau qui contient des variables et leurs valeurs. Voici un exemple de fonction compacte :

$low_cost = ‘Shared hosting’;
$mid_cost = ‘VPS hosting’;
$high_cost = ‘Dedicated hosting’;
compact (‘low_cost’, ‘mid_cost’, ‘high_cost’);
//[low_cost’ => “Shared hosting”, ‘mid_cost’ => “VPS hosting”, ‘high_cost’ => “Dedicated hosting”]

Dans sa documentation, la fonction compact n’accepte que des paramètres de type chaîne ou des tableaux contenant des valeurs de type chaîne. Cependant, il peut sembler qu’elle accepte des paramètres autres que des chaînes et des tableaux, mais en réalité elle les ignore.

Si vous déclarez des types stricts avec declare(strict_types=1), la fonction n’effectuera pas non plus de vérification des types stricts.

Cela a changé en PHP 8.1, car la fonction compacte affiche maintenant un avertissement si l’argument contient une non-valeur ou un tableau qui n’est pas constitué de clés de type chaîne.

compact(null);
// []
PHP Warning:  compact(): Argument #1 must be string or array of strings, null given in ... on line …

Cela dit, la déclaration de types stricts n’aura pas d’impact, et la fonction ne lancera toujours pas d’erreur de type.

L’algorithme de signature de Phar est passé de SHA1 à SHA256

L’extension Phar est utilisée pour emballer une application PHP dans un fichier d’archive Phar. Ce fichier peut ensuite être exécuté dans n’importe quel environnement PHP.

Chaque fichier Phar contient une signature pour vérifier l’intégrité du fichier avant son exécution. L’algorithme de signature par défaut pour le fichier Phar était auparavant SHA1. Cependant, dans PHP 8.1, cela change en SHA256.

Vous pouvez modifier l’algorithme de signature en utilisant Phar::setSignatureAlgorithm et en sélectionnant MD5, SHA1, SHA256 ou SHA512. Voici un extrait de code à ce sujet :

$filename = 'test.phar';
$phar = new Phar($filename);
$phar->buildFromDirectory('src/');
$phar->setDefaultStub('index.php', '/index.php');
$phar->setSignatureAlgorithm(Phar::SHA512);

Notez que toutes les versions de PHP depuis 5.3 supportent l’algorithme SHA256. Cela signifie que tous les fichiers Phar générés avec PHP 8.1 seront toujours compatibles avec les anciennes versions. Cependant, deux nouveaux algorithmes de signature – OpenSSL-256 et OpenSSL-512 – sont incompatibles avec les anciennes versions de PHP.

Implémentation de JsonSerializable dans SplFixedArray

SplFixedArray crée un nombre fixe d’éléments dans le tableau et les clés seront des entiers dans l’intervalle.

Dans les versions précédentes de PHP, la fonction json_encode encodait les instances SplFixedArray sous forme d’objets au lieu de tableaux. Cela va changer car SplFixedArray implémente l’interface JsonSerializable et l’encode comme des tableaux.

$array = new SplFixedArray(3);
$array[] = 'Web hosting';
$array[] = 'Domain name';
$array[] = 'SSL certificate';
echo json_encode($array);

Avant PHP 8.1, la sortie était la suivante :

{"0":"Web hosting","1":"Domain name","2":"SSL certificate"}

En PHP 8.1, ce sera comme ceci :

["Web hosting","Domain name","SSL certificate"]

Ressources pour les migrations d’objets

Le développement de PHP prévoit de déplacer les ressources vers des objets de classe standard.

L’un des problèmes est qu’il n’est pas possible d’utiliser le type de ressource. De plus, l’absence d’un type de ressource empêche certaines fonctionnalités liées aux ressources d’ajouter des types plus stricts.

Un autre défi est de maintenir certains types de ressources avec des fonctionnalités comme l’état interne, la gestion de la mémoire et le comptage des références. Par conséquent, dans ce cas, les classes PHP peuvent être utilisées à la place.

Ce sont quelques-unes des raisons pour lesquelles l’équipe PHP migre les types de ressources vers les objets. Cependant, les types de ressources ont été largement utilisés dans les applications PHP, l’équipe doit donc s’assurer que la migration ne soit pas perturbée.

Les ressources de connexion FTP sont maintenant des objets de classe FTP\Connection

Dans la version précédente de PHP, nous utilisions les fonctions ftp_connect() ou ftp_ssl_connect() pour créer une connexion FTP. Ces fonctions retournent une ressource de type ftp.

En PHP 8.1, ces fonctions retournent une classe FTP\Connection. Cette nouvelle classe est également déclarée finale, ce qui signifie que vous ne pouvez pas l’étendre. Cela minimise également les problèmes potentiels de compatibilité ascendante si le noyau de PHP modifie les méthodes de la classe FTP\Connection.

Les identifiants des polices GD sont maintenant des objets de classe GdFont

Dans les versions précédentes de PHP, la fonction imageloadfont() de l’extension GD était utilisée pour retourner un font-identifier de ressource dans un entier.

Dans la nouvelle version de PHP, l’ID de ressource a migré vers une classe GdFont.

Pour rendre le changement moins perturbant, toutes les fonctions qui acceptent un ID de ressource de imag eloadfont() acceptent également le nouvel objet de classe GdFont.

Les ressources file_info sont maintenant des objets finfo

Certaines des fonctions de l’extension finfo retournent et acceptent des objets ressources de type file_info. Ceci est maintenant changé en objets de classe finfo pour s’aligner avec le plan de migration de PHP.

Notez que la classe finfo est disponible depuis PHP 5.3. Cependant, les fonctions finfo_*() acceptent ou retournent des ressources. Ceci est maintenant corrigé, et il est même possible de changer les valeurs de retour en objets.

Ce sont les fonctions concernées par les changements :

• finfo_buffer()
• finfo_close()
• finfo_file()
• finfo_open()
• finfo_set_flags()

Les ressources imap sont maintenant des objets de classe IMAP\connection

Les ressources de IMAP connexion ont été migrées vers la classe IMAP\Connection. Avant cela, la fonction imap_open() renvoyait un objet ressource de typeimap.

Pour minimiser l’interruption de la migration, toutes les fonctions qui acceptent des ressources fonctionneront avec la nouvelle classe IMAP\Connection.

Comme la classe FTP\Connection, la classe IMAP\Connection est également déclarée finale pour éviter qu’elle ne soit étendue et qu’elle ne pose des problèmes de rétrocompatibilité.

Les ressources PostgreSQL sont désormais des objets \PgSql\Connection, \PgSql\Result, et \PgSql\Lob

PostgreSQL est une extension de base de données PHP qui utilise des objets ressources pour les connexions aux bases de données et les résultats. Trois objets ressources pour PostgreSQL ont été migrés en objets classes.

• ressource de pgsql link à la classe PgSql\Connection.
• ressource de pgsql result à la classe PgSql\Result.
• Ressource pgsql pour les objets de grande taille de la classe PgSql\Lob.

Toutes les fonctions PostgreSQL qui retournent et acceptent des objets ressources supportent maintenant les nouveaux objets classes.

Les ressources LDAP sont désormais des objets LDAP\Connection, LDAP\Result, et LDAP\ResultEntry

LDAP (Lightweight Directory Access Protocol) est une extension PHP permettant d’accéder aux serveurs d’annuaire, une base de données spéciale qui stocke les informations dans une structure arborescente.

Cette extension utilisait trois objets ressources avant PHP 8.1. Ces trois objets ont été migrés vers de nouvelles instances de classe.

• ressource de ldap link à la classe \LDAP\Connection.
• ressource de ldap result à la classe \LDAP\Result.
• ressource de ldap result entry à la classe \LDAP\ResultEntry.

Toutes les fonctions LDAP qui renvoient ou acceptent des objets ressources acceptent désormais les nouveaux objets classes.

Les ressources Pspell Config sont désormais des objets de classe PSpell\Dictionary, PSpell\Config

L’extension PHP Pspell permet de vérifier l’orthographe et fournit des suggestions de mots. Elle utilise les types d’objets ressources pspell et pspell config avec un identifiant entier.

Ces objets ressources ont été remplacés par les objets de classe PSpell\Dictionary et PSpell\Config en PHP 8.1. Voici les fonctions permettant de créer les objets PSpell\Dictionary et PSpell\Config :

• pspell_new()
• pspell_new_config()
• pspell_new_personal()
• pspell_config_create()

Comme les autres ressources migrées, toutes les fonctions qui acceptent les ressources pspell et pspell config accepteront également PSpell\Dictionary et PSpell\Config.

Dépréciations en PHP 8.1

PHP 8.1 a déprécié plusieurs fonctionnalités, dont plus de dix fonctions PHP déjà existantes. Voici le récapitulatif des fonctionnalités et des fonctions qui ont été dépréciées en PHP 8.1.

Restrictions d’utilisation de $Globals

La variable $GLOBALS donne des références à toutes les variables de portée globale. Elle contient également les valeurs “superglobales”, notamment $_GET, $_SERVER et $_ENV.

PHP 8.1 ne déprécie pas complètement cette fonctionnalité mais restreint toute modification du tableau $GLOBALS, comme la destruction du tableau, l’écrasement de sa valeur, et la référence à la variable $GLOBALS.

En effet, la prise en charge de certains comportements de variables $GLOBALS nécessite un travail technique complexe.

Si vous essayez d’effectuer ces modifications sous PHP 8.1, vous obtiendrez une erreur fatale. Voici un exemple de modification en masse de la variable $GLOBALS :

$GLOBALS = [];
$GLOBALS = ['foo' => 1, 'bar' => 2];
$GLOBALS = get_new_vars();
$GLOBALS =& $new_vars;
list($GLOBALS) = [1];
foreach ($new_var_c as $GLOBALS) {}
unset($GLOBALS);

Il en résultera l’erreur suivante :

Fatal error: $GLOBALS can only be modified using the $GLOBALS[$name] = $value syntax in ... on line …

Notez que l’utilisation en lecture seule de la variable $GLOBALS et la modification des éléments individuels du tableau sont toujours autorisées.

Le passage de null à une fonction interne non-nullable n’est pas autorisé.

En PHP, vous ne devriez pas pouvoir passer des valeurs nulles à des fonctions non nulles. Cette restriction fonctionnait pour les fonctions définies par l’utilisateur dans les versions précédentes de PHP. Les fonctions internes acceptaient les valeurs nulles en silence.

Pour maintenir la cohérence, les fonctions internes n’acceptent plus les valeurs nulles. Passer null à des arguments non-nullables retournera un avis de dépréciation.

var_dump(str_contains("foobar", null));
Deprecated: Passing null to argument of type string is deprecated

Cette dépréciation fait partie d’un plan visant à supprimer la fonctionnalité. Selon sa RFC, le passage de valeurs nulles à des fonctions internes non nulles entraînera une TypeError. Cela rendra les fonctions internes cohérentes avec le comportement actuel des fonctions définies par l’utilisateur.

Fonctions dépréciées

PHP 8.1 déprécie également 11 fonctions PHP qui peuvent affecter les applications existantes.

Interface sérialisable dépréciée

Les classes PHP ont leur propre logique de sérialisation. Par exemple, elles peuvent empêcher la sérialisation de certaines données sensibles ou rétablir des connexions à un serveur distant en utilisant du texte sérialisé. Elles utilisent trois méthodes différentes :

• Les méthodes magiques __sleep et __wakeup.
• Interface Serializable, méthodes Serializable::serialize et Serializable:unserialize.
• Les méthodes magiques __serialize et __unserialize.

__serialize et __unserialize ont été introduites en PHP 7.4 pour résoudre le problème de l’interface Serializable. Cependant, le plan final est de supprimer l’interface Serializable dans les futures versions de PHP.

En PHP 8.1, l’implémentation de l’interface Serialize sur une classe sans les méthodes __serialize et __unserialize entraînera une erreur de dépréciation.

class Test implements Serializable{
    public function serialize() {}
    public function unserialize($data) {}
}

Il en résultera le message d’erreur suivant :

Deprecated: Test implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary) in ... on line …

Cependant, il est toujours possible d’implémenter une interface Serializable tant que la classe implémente également les méthodes magiques __serialize et __unserialize.

class Test implements Serializable{
    public function __serialize(): array {}
    public function __unserialize(array $data): void {}
    public function serialize(): array {}
    public function unserialize(string $data): void {}

L’interface Serializable décode la charge utile de sérialisation existante, et la notice de dépréciation n’apparaîtra pas. Si l’application ne nécessite pas le support de PHP 7.3, vous pouvez remplacer l’interface Serializable par les méthodes magiques __serialize et __unserialize.

Autovivification dépréciée sur False

L’autovivification est l’auto-création de tableaux à partir de valeurs fausses et nulles. Bien que cette fonctionnalité soit largement utilisée dans les applications PHP, la création automatique d’un tableau à partir de valeurs fausses n’est pas idéale car elle peut être le signe d’un code bogué.

Ainsi, PHP 8.1 déprécie l’autovivification uniquement pour les valeurs fausses. Implémenter l’autovivification sur une fausse variable en PHP 8.1 résultera en un avis de dépréciation.

$arr = false;
$arr[] = 2;
Deprecated: Automatic conversion of false to array is deprecated in

Dans les prochaines versions, le plan est d’émettre une erreur fatale sur une telle mise en œuvre. Comme pour les valeurs indéfinies et nulles, l’autoviviation est toujours autorisée.

Déprécié mysqli::get_client_info et mysqli_get_client_info ($param)

Le passage de paramètres à la fonction mysqli_get_client_info() et la méthode mysqli::get_client_info sont utilisés pour renvoyer la version du client MySQLi par le biais de la constante chaîne client_info.

Avant PHP 8.1, il y a quatre options possibles pour exposer la constante client_info :

• mysqli_driver properties
• mysqli properties
• mysqli_get_client_info() function
• mysqli::get_client_info method

D’autre part, MySQL Native Driver (MySQLnd) expose la constante avec seulement deux options – une constante et un appel de fonction.

Le passage de paramètres à la fonction mysqli_get_client_info() et mysqli::get_client_info est maintenant déprécié dans un effort d’unifier la méthode d’accès.

L’utilisation de la méthode get_client_info dans la classe mysqli émet désormais un avis de dépréciation.

$info = $connection->get_client_info();
Deprecated: Method mysqli::get_client_info() is deprecated in …

Le passage de paramètres à la fonction mysqli_get_client_info() entraînera également une notification de dépréciation :

$info = mysqli_get_client_info($connection);
Deprecated: mysqli_get_client_info(): Passing connection object as an argument is deprecated in …

Plutôt que d’utiliser les options obsolètes, utilisez la fonction mysqli_get_client_info() sans paramètres.

$info = mysqli_get_client_info();

Déprécié Conversion Implicite Incompatible de Float en Int

La coercition de type est courante en PHP, et dans la plupart des cas, elle est utile. Cependant, le problème se pose lorsqu’un nombre flottant est converti en un nombre entier, car cela peut entraîner une perte de données. Par exemple, 1,618 sera converti en 1, perdant ainsi sa valeur fractionnaire.

PHP 8.1 résout ce problème en émettant un avis de dépréciation si un flottant non compatible est implicitement converti en entier. Cette notification devrait empêcher la perte involontaire de valeurs fractionnaires.

Voici un exemple de déclaration d’une fonction avec un type de retour int. Lorsque la fonction est appelée, PHP convertira la valeur de 1.618 en un entier, générant un avis de dépréciation :

function get_integer(): int {
Return ‘1.618’:
}
get_integer();
PHP Deprecated:  Implicit conversion from float-string "6.8" to int loses precision in ... on line ...

La notification de dépréciation ne sera pas émise si la valeur est un flottant compatible avec les nombres entiers. Selon la RFC, voici les caractéristiques d’un flottant compatible avec les nombres entiers :

• C’est un numéro.
• Il est dans l’intervalle d’un entier de PHP.
• Il n’a pas de partie fractionnaire.

Paramètres INI de filter.default et filter.default_options dépréciés

Le paramètre INI filter.default applique un filtre à tous les super globaux de PHP en fonction de sa valeur. La valeur par défaut de ce paramètre est filter.default=unsafe_raw – il évite toute application de filtre sur les super globaux.

Le problème avec ce paramètre est qu’il peut ramener la fonctionnalité des guillemets magiques avec la valeur filter.default=magic_quotes. Cette fonctionnalité a été supprimée en PHP 5.4 en raison d’une approche peu fiable de l’assainissement des entrées utilisateur.

Pour pallier ce problème, l’attribution d’une valeur autre que unsafe_raw au paramètre filter.default INI émettra un avis de dépréciation PHP au moment du démarrage. Il n’y a pas d’avertissement séparé pour filter.default_options, mais ces deux paramètres INI seront supprimés dans la prochaine version majeure de PHP.

Déprécié date_sunrise et date_sunset

Les fonctions date_sunrise() et date_sunset() renvoient les heures de lever et de coucher du soleil en prenant les valeurs par défaut date.default_latitude et date.default_longitude des paramètres INI de PHP. Malheureusement, aucune autre fonction n’utilise ces paramètres INI, et le concept lui-même n’a pas beaucoup de sens.

Par conséquent, les fonctions date_sunrise() et date_sunset() sont dépréciées dans PHP 8.1 et remplacées par la fonction date_sun_info(). En accord avec cette dépréciation, les paramètres INI suivants sont également dépréciés :

• date.default_latitude
• date.default_longitude
• date.sunrise_zenith
• date.sunset_senith

L’utilisation des fonctions date_sunrise et date_sunset en PHP 8.1 émettra un avertissement de dépréciation. Cependant, la définition des valeurs INI correspondantes ou l’utilisation de la fonction ini_set ne génèrera pas l’avertissement.

Déprécié strptime

La fonction strptime() analyse les chaînes de date ou d’heure dans des tableaux. L’utilisation de cette fonction sur certaines distributions Linux comme Alpine peut entraîner un comportement inattendu car elle utilise la bibliothèque C musl. De plus, cette fonction est locale et peut être affectée si vous exécutez un autre code dans un autre thread.

Le manuel de la fonction recommande l’utilisation de date_parse_from_format() car elle est plus cohérente et ne souffre pas des mêmes problèmes. D’autres alternatives sont également disponibles, comme DateTime::createFromFormat(), plus orientée objet, et IntlDateFormatter::parse() pour une analyse dépendante des paramètres locaux.

En conséquence, la fonction strptime() est dépréciée au profit d’options plus cohérentes.

Dépréciations de strftime et gmstrftime

Les fonctions strftime() et gmstrftime() sont similaires à strptime(). Elles formatent un horodatage en fonction des paramètres régionaux, sauf que gmstrftime renvoie l’heure en GMT.

Malheureusement, ces fonctions souffrent des mêmes problèmes que strptime() en termes de formats pris en charge et de comportements.

Ces fonctions sont dépréciées et remplacées par la fonction date() ou DateTime::format(). Pour une utilisation dépendant de la localisation, IntlDateFormatter::format est le remplacement idéal.

Deprecated mhash*() or hash extensions

Les fonctions mhash*() ont été apportées à PHP par l’extension mhash. Cependant, cette extension a été remplacée par l’extension hash en PHP 5.3. Il n’est possible d’utiliser ces fonctions qu’avec une extension hash et l’option de configuration PHP --enable-mhash.

Depuis PHP 7.4, l’extension hash est devenue un paquet avec PHP. Les fonctions mhash*()sont toujours utilisables car l’option --enable-mhash est toujours supportée pour des raisons de compatibilité.

Toutefois, l’équipe PHP a déprécié mhash*() functions en PHP 8.1 et les supprimera en PHP 9.0. L’utilisation mhash*() functions suivantes retournera un avertissement de dépréciation :

• mhash
• mhash_count
• mhash_get_block_size
• mhash_get_hash_name
• mhash_keygen_s2k

Puisque le hachage est maintenant l’extension par défaut, nous recommandons d’utiliser les fonctions hash*() à la place.

Déprécié PDO::FETCH_SERIALIZE

PDO::FETCH_SERIALIZE est utilisé comme un drapeau pour les méthodes de récupération des déclarations PDO. Ensuite, PDO est censé appeler unserialize sur les données extraites de la base de données.

Cette fonctionnalité est cependant inutilisable. De plus, avec la dépréciation de l’interface Serializable, l’équipe PHP a également décidé de déprécier PDO::FETCH_SERIALIZE.

L’utilisation de PDO::FETCH_SERIALIZE en PHP 8.1 retournera un avis de dépréciation.

Déprécié MySQLi : propriété mysqli_driver->driver_version

La propriété mysqli_driver->driver_version dans l’extension MySQLi est censée retourner la valeur de la version du pilote. Cependant, cette propriété n’a pas été mise à jour depuis 13 ans malgré les nombreuses modifications apportées au pilote.

Par conséquent, cette propriété a été rendue inutile et dépréciée en PHP 8.1.

Conclusion

En tant que nouvelle version majeure, PHP 8.1 apporte beaucoup de nouvelles fonctionnalités, de changements et de dépréciations qui sont de bonnes nouvelles pour les développeurs PHP.

Par exemple, les fonctionnalités comme les fibres devraient ouvrir de nouvelles possibilités d’être créatif dans l’exécution du codage. Même les petits changements comme la conversion des guillemets simples en entités HTML sont les bienvenus.

Vous pouvez consulter la documentation officielle de PHP pour voir la liste complète des RFC ou la liste des dépréciations pour plus d’informations sur PHP 8.1.

Hostinger prendra en charge PHP 8.1, mais nous conserverons les options pour les anciennes versions de PHP au cas où vous en auriez besoin. Cependant, nous vous recommandons vivement de passer à PHP 8.1 pour accéder aux nouvelles améliorations et maintenir la compatibilité avec les frameworks et les bibliothèques.