PHP 8.3 : Nouveautés et changements de la dernière version

Capture d'écran du code PHP 8.3 et nouvelles fonctionnalités.

Table des matières

PHP 8.3, publié le 23 novembre, a introduit d'importantes nouvelles fonctionnalités et améliorations par rapport à sa version précédente, PHP 8.2. Cette version, bien que considérée comme "mineure", apporte des changements significatifs qui peuvent avoir un impact important sur le développement de PHP. Voyons les principales nouveautés et mises à jour de PHP 8.3.

Nouvelles fonctionnalités et améliorations de PHP 8.3 PHP 8.3 a introduit plusieurs nouvelles fonctionnalités et améliorations :

Constantes de classe typées en PHP 8.3 : une révolution dans la programmation

PHP 8.3 introduit une fonctionnalité révolutionnaire : le typage des constantes de classe. Bien que PHP ait déjà introduit le typage pour les propriétés de classe en PHP 7.4, cette innovation n'avait pas encore été étendue aux constantes. Jusqu'à maintenant.

La nouvelle version étend le typage aux constantes de classe, y compris celles des interfaces, des traits et des enums. Ce changement présente l'avantage important de minimiser le risque que les développeurs s'écartent de l'intention initiale d'une constante, garantissant ainsi une plus grande clarté et une meilleure sécurité dans le code.

Pour illustrer ce propos, voici un exemple pratique :

// Correct :
interface ConstTest {
const string VERSION = "PHP 8.3" ; // Le type et la valeur sont tous deux des chaînes de caractères
}

// Incorrect :
interface ConstTest {
const float VERSION = "PHP 8.3" ; // Erreur de type et de valeur
}

L'efficacité des constantes de classe typées devient évidente lorsqu'on travaille avec des classes dérivées. Dans les versions précédentes, une sous-classe pouvait changer la valeur d'une constante, mais avec PHP 8.3, il est maintenant possible d'empêcher les changements accidentels du type d'une constante, tout en préservant la cohérence avec la déclaration originale.

Par exemple :

class ConstTest {
const string VERSION = 'PHP 8.2' ;
}

class MyConstTest extends ConstTest {
// Correct : la modification de la valeur de VERSION est autorisée
const string VERSION = 'PHP 8.3' ;

// Faux : le type doit être déclaré comme dans la classe de base
const VERSION = 'PHP 8.3' ;

// Faux : il n'est pas possible de modifier le type déclaré dans la classe de base.
const float VERSION = 8.3 ;
}

Notez qu'il est possible de "restreindre" le type d'une constante de classe dans une sous-classe, en utilisant un type compatible ou plus spécifique :

class ConstTest {
const string|float VERSION = 'PHP 8.2' ;
}

class MyConstTest extends ConstTest {
// Correct : il est possible de spécifier le type comme string ou float
const string VERSION = 'PHP 8.3' ;
const float VERSION = 8.3 ;

// Correct : bien que la valeur puisse être un int, elle est compatible avec un float.
const float VERSION = 8 ;

// Faux : il n'est pas possible d'étendre les options de type en incluant int
const string|float|int VERSION = 8 ;
}

Cependant, il est important de noter que deux types, vide e jamaislargement utilisé pour les propriétés et

ne sont pas supportés comme types de constantes de classe en PHP 8.3.

En résumé, le typage constant des classes en PHP 8.3 représente un bond en avant dans le développement de logiciels. Il fournit aux programmeurs un outil supplémentaire pour s'assurer que le code n'est pas seulement fonctionnel, mais aussi précis et fidèle aux intentions initiales, réduisant ainsi les erreurs et améliorant la lisibilité et la maintenabilité du code. Cette innovation marque une nouvelle évolution du typage en PHP, consolidant sa position en tant que langage de programmation moderne et robuste.

Nouvelle fonction en PHP 8.3 : json_validate()

La manipulation des données encodées en JSON è una pratica comune nello développement web. In PHP 8.3, una nuova funzione, json_validate()a été introduite pour améliorer considérablement ce processus. Cette fonction est particulièrement utile pour vérifier la validité syntaxique d'une charge utile JSON avant de l'utiliser.

Dans les versions précédentes de PHP, les développeurs utilisaient la fonction json_decode() pour vérifier les erreurs lors de la conversion des données JSON en tableaux associatifs ou en objets. Toutefois, cette méthode nécessitait l'utilisation de ressources importantes pour construire les structures de tableaux ou d'objets, même lorsque le seul but était de vérifier l'intégrité du JSON.

Voici un exemple de la façon dont le json_decode() pour valider une charge utile JSON :

$obj = json_decode($maybeJSON) ;

if (json_last_error() == JSON_ERROR_NONE) {
// Exécuter des opérations avec $obj
}

Dans ce scénario, les ressources étaient principalement utilisées pour établir la validité de la charge utile JSON, ce qui n'était pas très efficace en termes d'utilisation de la mémoire.

Avec l'arrivée de PHP 8.3, il est possible d'effectuer la même opération plus efficacement en utilisant json_validate():

if (json_validate($maybeJSON)) {
// Exécution d'opérations avec $maybeJSON
}

Important : Il convient de rappeler qu'il n'est pas optimal d'utiliser json_validate() puis de passer les données par l'intermédiaire de json_decode()car cela utiliserait encore des ressources de mémoire pour le décodage. L'approche idéale consiste à utiliser json_validate() pour confirmer la validité du JSON avant de procéder à d'autres opérations, telles que l'enregistrement des données ou leur transmission en réponse à une demande. Cela permet d'optimiser l'utilisation des ressources et de garantir un traitement plus efficace des données JSON.

Clonage profond des propriétés en lecture seule en PHP 8.3

PHP 8.3 a introduit une amélioration significative dans la gestion des propriétés en lecture seule dans les classes. Cette fonctionnalité, initialement introduite en PHP 8.1 pour les propriétés individuelles, puis étendue aux classes entières en PHP 8.2, a été développée grâce à une récente RFC (Request For Comments).

Le problème abordé était l'inflexibilité de l'utilisation de classes avec des propriétés en lecture seule, ce qui limitait certaines possibilités de programmation. Le RFC proposait deux solutions principales :

  1. Autoriser l'extension des classes non lisibles à partir des classes lisibles.
  2. Permettre la réinitialisation des propriétés en lecture seule lors du clonage.

La seconde proposition, adoptée en PHP 8.3, a permis de faire une avancée dans la gestion des propriétés en lecture seule. Cette nouvelle fonctionnalité permet, lors d'un clonage profond, de réinitialiser les instances d'une classe ayant des propriétés en lecture seule dans le cadre de l'application méthode magique __clone. Cela signifie que les fonctions invoquées par __clone peut légalement modifier ces propriétés.

Voici un exemple pratique tiré du RFC illustrant le nouveau comportement :

class Foo {
public function __construct(
public readonly DateTime $bar,
public readonly DateTime $baz
) {}

public function __clone() {
// Lors du clonage, $bar recevra un nouvel objet DateTime
$this->bar = clone $this->bar ;

// Cette fonction sera appelée
$this->cloneBaz() ;
}

private function cloneBaz() {
// Cette opération est légale lorsqu'elle est appelée à l'intérieur de __clone
unset($this->baz) ;
}
}

$foo = new Foo(new DateTime(), new DateTime()) ;
$foo2 = clone $foo ;

Cette nouvelle fonctionnalité accroît considérablement la souplesse d'utilisation des classes dotées de propriétés en lecture seule, ce qui permet d'utiliser des modèles de conception plus avancés et plus sophistiqués, tout en préservant l'intégrité et la sécurité qu'offrent les propriétés en lecture seule.

Introduction au nouvel attribut #[\NOverride] en PHP 8.3

PHP 8.3 a introduit une nouvelle fonctionnalité importante qui améliore de manière significative la clarté et la précision du code : la fonction #[\NPasser outre]. Ce nouvel attribut est crucial lorsque l'on travaille avec l'héritage et les interfaces en PHP, car il fournit une confirmation explicite qu'une méthode dans une classe fille est destinée à surcharger une méthode dans la classe mère ou à implémenter une méthode définie dans une interface.

Problème résolu par #[\N- Override] : En programmation, il peut arriver qu'une méthode d'une classe dérivée soit écrite avec l'intention de remplacer une méthode de la classe mère ou d'implémenter une méthode d'une interface. Cependant, des erreurs telles que des fautes de frappe dans le nom de la méthode peuvent faire en sorte que la méthode ne remplace pas réellement la méthode prévue, ce qui entraîne un comportement inattendu difficile à détecter.

Fonctionnement de #[\N-override] : L'attribut #[\NOverride] est utilisé pour s'assurer que la méthode dans une classe dérivée est en fait une surcharge d'une méthode dans la classe mère ou une implémentation d'une méthode dans une interface. Si une méthode marquée avec l'attribut #[\NOverride] ne correspond pas à une méthode de la classe mère ou de l'interface, PHP génère une erreur, rendant le problème immédiatement apparent.

Exemple pratique :

classe A {
protected function ovrTest() : void {}
}

class B extends A {
#[\NPasser outre]
public function ovrTest() : void {} // Correct : écrase la fonction ovrTest() de A
}

class C extends A {
#[\NPasser outre]
public function ovrBest() : void {} // Erreur : ovrBest() n'existe pas dans A
}

Récupération dynamique des constantes de classe et des membres d'énumération

PHP 8.3 a également simplifié la récupération dynamique des constantes de classe et des membres d'énumération. Auparavant, pour obtenir la valeur d'une constante de classe ou d'un membre d'enum en utilisant une variable pour le nom, il fallait utiliser la fonction constante(). Cette méthode est moins directe et peut s'avérer plus complexe dans certains cas.

Maintenant, avec PHP 8.3, il est possible d'accéder directement à ces constantes et membres en utilisant une syntaxe plus simple et plus directe :

class MyClass {
public const THE_CONST = 9 ;
}

enum MyEnum : int {
case FirstMember = 9 ;
case SecondMember = 9 ;
}

$constantName = 'THE_CONST' ;
$memberName = 'FirstMember' ;

echo MyClass::{$constantName} ; // Accès direct à la constante de classe
echo MyEnum::{$memberName}->value ; // Accès direct au membre de l'énumération

Ces innovations dans PHP 8.3, les deux #[\NPasser outre] et l'amélioration de la récupération dynamique des constantes, représentent des étapes importantes vers un code plus clair, plus sûr et plus facile à maintenir.

PHP 8.3 a introduit une méthode innovante et utile pour générer des chaînes aléatoires : getBytesFromString(). Cette méthode, ajoutée à l'extension Random de PHP, simplifie grandement la création de chaînes de caractères aléatoires à partir d'un jeu de caractères prédéfini.

Comment fonctionne la fonction getBytesFromString() : La fonctionnalité est assez simple. Vous fournissez une chaîne de caractères dans laquelle vous pouvez puiser et vous spécifiez la longueur souhaitée pour la chaîne aléatoire. La méthode getBytesFromString() sélectionnera alors aléatoirement des octets de votre chaîne source, jusqu'à ce que la longueur spécifiée soit atteinte.

Exemples pratiques :

$rando = new Random\Randomizer() ;
$alpha = 'ABCDEFGHJKMNPQRSTVWXYZ' ;

// Génère une chaîne aléatoire de 6 caractères à partir de $alpha
echo $rando->getBytesFromString($alpha, 6) ; // Par exemple : "MBXGWL".

Un aspect intéressant de la getBytesFromString() est qu'il permet de générer des chaînes aléatoires plus longues que la chaîne d'entrée. Par exemple, il est possible de générer des chaînes aléatoires plus longues que la chaîne d'entrée :

$rando = new Random\Randomizer() ;
$nums = '123456' ;

// Générer une chaîne aléatoire de 10 chiffres à partir de $nums
echo $rando->getBytesFromString($nums, 10) ; // Par exemple : '2526341615'.

Pondération des caractères dans l'entrée : Une autre caractéristique de cette méthode est la possibilité de "peser" les caractères dans l'entrée. Si certains caractères apparaissent plus fréquemment dans la chaîne d'entrée, ils ont plus de chances d'être sélectionnés dans la chaîne aléatoire. Par exemple :

$rando = new Random\Randomizer() ;
$weighted = 'YYYY12345' ;

// Génère une chaîne aléatoire où "A" a plus de chances d'apparaître
echo $rando->getBytesFromString($weighted, 5) ; // Par exemple : "1AA53".

En conclusion, le getBytesFromString() en PHP 8.3 offre une solution simple et efficace pour générer des chaînes aléatoires, avec la possibilité de personnaliser la distribution des caractères et la longueur de la chaîne résultante. Cela en fait un outil précieux pour une variété d'applications, du traitement des données à la sécurité informatique.

Autres changements et améliorations dans PHP 8.3

En plus des nouvelles fonctionnalités importantes déjà évoquées, PHP 8.3 introduit un certain nombre de nouvelles fonctionnalités. améliorations et fonctionnalités supplémentaires qui enrichissent encore la langue. Nous présentons ci-dessous quelques-unes de ces mises à jour mineures qui, malgré leur petite taille, peuvent avoir un impact significatif sur le développement quotidien.

  1. Nouvelles méthodes pour la classe DOMElement : PHP 8.3 améliore la gestion du DOM avec des méthodes supplémentaires telles que DOMElement::getAttributeNames(), DOMElement::insertAdjacentElement(), DOMElement::insertAdjacentText()et d'autres, améliorant la manipulation des nœuds du DOM.
  2. Mises à jour pour IntlCalendar : La classe IntlCalendar a été complété par des méthodes telles que IntlCalendar::setDate() e IntlCalendar::setDateTime()offrant une plus grande flexibilité dans la gestion des dates.
  3. Mise à jour des fonctions LDAP : Les nouvelles fonctions ldap_connect_wallet() e ldap_exop_sync() étendre les capacités d'intégration de LDAP.
  4. Amélioration des fonctions multioctets : La nouvelle fonction mb_str_pad() ajoute des options supplémentaires pour la manipulation des chaînes de caractères multi-octets.
  5. Nouvelles fonctions POSIX : Les fonctions telles que posix_sysconf() e posix_eaccess() ont été introduites pour améliorer l'interaction avec le système d'exploitation.
  6. Nouvelle méthode dans ReflectionMethod : La méthode ReflectionMethod::createFromMethodName() offre plus de souplesse dans la réflexion sur les méthodes.
  7. Mise à jour des fonctions des sockets : La fonction socket_atmark() élargit les capacités de mise en réseau.
  8. Nouvelles fonctions pour les chaînes de caractères : str_increment(), str_decrement(), e estream_context_set_options() sont quelques-unes des nouvelles fonctions introduites pour la manipulation des chaînes de caractères.
  9. Nouvelle méthode dans ZipArchive : ZipArchive::getArchiveFlag() offre de nouvelles possibilités de gestion des archives ZIP.
  10. Nouveau paramètre INI : La zend.max_allowed_stack_size permet de configurer la taille maximale de la pile, ce qui améliore la gestion des ressources.

Dépréciations en PHP 8.3

Chaque nouvelle version de PHP apporte également une liste de fonctions et de paramètres qui sont obsolètes. Il est important de noter ces dépréciations, car l'utilisation continue de ces fonctions peut conduire à des avertissements dans les journaux et à des problèmes de compatibilité potentiels.

Parmi les dépréciations de PHP 8.3, on peut citer

  • La correction de la constante U_MULTIPLE_DECIMAL_SEPERATORS à U_MULTIPLE_DECIMAL_SEPARATORS.
  • L'abandon de la variante 3MT_RAND_PHP Mt19937.
  • Changements dans la ReflectionClass::getStaticProperties().
  • Divers paramètres INI tels que assert.active, assert.bailetc.
  • Appels sans arguments à get_class() e get_parent_class() sont désormais obsolètes.

PHP 8.3 disponible chez G Tech Group

En conclusion, PHP 8.3 représente une avancée significative dans le développement du langage, introduisant un certain nombre de nouvelles fonctionnalités, d'améliorations et de dépréciations cruciales pour la modernisation et l'optimisation du code PHP. Avec l'ajout de méthodes plus avancées, une plus grande flexibilité et l'introduction de nouvelles fonctions, PHP 8.3 se positionne comme un excellent choix pour les développeurs cherchant à améliorer les performances et la sécurité de leurs applications.

Pour ceux qui utilisent des services d'hébergement et de serveur, nous avons de bonnes nouvelles : Groupe G Tech a déjà implémenté PHP 8.3 sur tous ses systèmes d'hébergement et serveurs. Cela signifie qu'en tant que client du Groupe G Tech, vous pouvez immédiatement profiter de tous les avantages offerts par la dernière version de PHP, sans devoir procéder à des mises à jour manuelles ou à des configurations complexes.

Cette implémentation fait partie de l'engagement du Groupe G Tech à fournir les technologies les plus avancées et les plus récentes à ses clients, en s'assurant que vos projets sont toujours soutenus par les meilleures et les plus récentes solutions disponibles sur le marché. Avec PHP 8.3 sur G Tech Group, vous pouvez compter sur un environnement d'hébergement robuste, sécurisé et performant, idéal pour le développement et la croissance de vos applications web.

Laisser un commentaire

Laisser un commentaire

G Tech Group est né en 2011 et en 2013 d'une idée de Gianluca Gentile, son fondateur.

L'objectif était de créer la première Agence web sociale Il ne s'agit pas d'une agence web classique qui s'occupe du social, mais d'une agence qui partage ses ressources et ses idées avec d'autres agences et qui connecte également différentes agences, créant ainsi un véritable réseau.

Messages récents

Vous souhaitez améliorer le score de votre site ?

Nous avons une solution idéale pour le marketing de votre entreprise
PHP 8.3, nouvelles fonctionnalités de PHP, améliorations de PHP, dépréciations de PHP, développement de PHP
Groupe G Tech