IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage PHP Discussion :

PHP 8 est disponible et s'accompagne de nouvelle fonctionnalités incluant les arguments nommés


Sujet :

Langage PHP

  1. #1
    Chroniqueur Actualités

    Homme Profil pro
    Rédacteur technique
    Inscrit en
    juin 2016
    Messages
    2 082
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations professionnelles :
    Activité : Rédacteur technique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : juin 2016
    Messages : 2 082
    Points : 45 965
    Points
    45 965
    Par défaut PHP 8 est disponible et s'accompagne de nouvelle fonctionnalités incluant les arguments nommés
    PHP 8 : voici un aperçu des nouveautés attendues dans la prochaine version majeure du langage,
    selon un développeur PHP

    L’année 2020 s’annonce très importante pour le langage PHP. PHP 7.4 a été publié en décembre dernier et l’équipe de développement du langage travaille déjà sur PHP 8, la prochaine version majeure. Pour la nouvelle version, beaucoup de choses devraient changer ou bien subir des améliorations et de nombreuses nouvelles fonctionnalités sont également attendues. Ces dernières comprennent le compilateur JIT (Just In Time) et les types union. PHP 8 devrait être publié vers la fin de l’année.

    L'introduction d'un compilateur JIT dans PHP 8 a été proposée en avril 2019. Le but est d’améliorer les performances du langage en matière de vitesse. D’autres améliorations significatives de performances sont citées, bien que pas toujours dans le contexte des requêtes Web. L’on estime qu’il n'y a pas encore eu d'évaluation précise des performances à ce stade, mais elles viendront certainement. En gros, JIT est une technique qui permettra de compiler des parties du code au moment de l'exécution, de sorte que la version compilée puisse être utilisée à la place.

    Nom : php_logo.png
Affichages : 144656
Taille : 17,7 Ko

    Selon Christian Brent, un programmeur PHP, la prochaine version majeure du langage apporte bien plus qu’un compilateur JIT. Voici, selon Brent, un petit aperçu de ce qui est prévu dans PHP 8 :

    Les types Union

    Les types Union peuvent être utiles dans plusieurs cas. Les types Union sont une collection de deux ou plusieurs types qui indiquent que l'un ou l'autre peut être utilisé. Cependant, le type “void” ne peut pas faire partie d'un type Union, puisqu'il n’indique aucune valeur de retour. De plus, les unions annulables peuvent être écrites en utilisant | null, ou en utilisant la notation “?”.

    Type de retour static

    Il est déjà possible de retourner le type self. À partir de PHP 8, le type static devrait aussi devenir un type de retour valide. Étant donné la nature dynamique de PHP, cette fonctionnalité pourrait bien être utile à de nombreux développeurs.

    Les Weakmaps

    Cette fonctionnalité est basée sur la RFC Weakrefs qui a été ajoutée dans PHP 7.4. Les WeakMaps contiennent des références à des objets, ce qui n'empêche pas ces objets d'être collectés comme des ordures. Prenons l'exemple des ORM. Ils implémentent souvent des caches qui contiennent des références à des classes d'entités afin d'améliorer les performances des relations entre les entités. Ces objets d'entités ne peuvent pas être collectés, tant que ce cache contient une référence à ces objets, même si le cache est la seule chose qui les référence.

    Si cette couche de cache utilise des références et des WeakMaps à la place, PHP peut mettre ces objets à la poubelle lorsque plus rien d'autre ne les référencera. Puisque les ORM peuvent gérer plusieurs centaines, voire milliers d'entités dans une requête, les WeakMaps offrent une façon, plus respectueuse des ressources, de traiter ces objets.

    La fonction fdiv

    PHP 8 devrait introduire une nouvelle fonction fdiv. Elle fait quelque chose de semblable aux fonctions fmod et intdiv, qui permettent une division par 0. Au lieu d'erreurs, vous obtiendrez INF, -INF ou NAN, selon le cas.

    Les erreurs de type cohérentes

    Les fonctions définies par l'utilisateur déclenchent des erreurs dans PHP, mais les fonctions internes ne le font pas. Elles émettent plutôt des avertissements et renvoient un message nul. Avec PHP 8, le comportement des fonctions internes a été rendu cohérent.

    Créer des objets DateTime à partir de l'interface

    Les récentes versions de PHP permettent déjà de créer un objet DateTime à partir d'un objet DateTimeImmutable, mais l'inverse était très délicat. Il existe désormais un moyen généralisé de convertir les objets DateTime et DateTimeImmutable l'un vers l'autre.

    Les avertissements seront revus dans PHP 8

    Beaucoup d'erreurs PHP déclenchaient seulement des avertissements ou des avis. À partir de PHP 8, elles seront converties en erreurs correctes. Les avertissements suivants ont été modifiés :

    • variable indéfinie : déclenche une erreur d'exception au lieu d'un avis ;
    • indice de tableau indéfini : déclenche un avertissement au lieu d'avis ;
    • Tentative d'incrémentation/diminution de la propriété “%s” d’un non-objet : déclenche une erreur d’exception au lieu d’un avertissement ;
    • tentative de modification de la propriété “%s” d’un non-objet : déclenche une erreur d’exception au lieu d'avertissement ;
    • tentative d'attribution de propriété “%s” d’un non-objet : déclenche une erreur d’exception au lieu d'un avertissement ;
    • création d'un objet par défaut à partir d'une valeur vide : déclenche une erreur d’exception au lieu d'un avertissement ;
    • impossible d'ajouter un élément au tableau, car l'élément suivant est déjà occupé : déclenche une erreur d’exception au lieu d'un avertissement ;
    • ne peut pas annuler le décalage d'une variable qui n'est pas un tableau : déclenche une erreur d’exception au lieu d'un avertissement ;
    • ne peut pas utiliser une valeur scalaire comme tableau : déclenche une erreur d’exception au lieu d'un avertissement ;
    • etc.


    En outre, une petite nouveauté utile qui pourrait aussi arrivé dans PHP 8 : il est désormais possible d'utiliser ::class sur les objets, au lieu de devoir utiliser get_class(). Cela fonctionne de la même manière que get_class(). Par ailleurs, PHP 8 est une version majeure, ce qui signifie qu’il pourrait y avoir des changements radicaux. La meilleure chose à faire est de s’informer de la liste complète des changements dans PHP 8 au fur et à mesure que son développement évolue. Toutefois, si vous avez été à jour au fil des ans, il ne devrait pas être très difficile de passer à PHP 8.

    Source : Christian Brent

    Et vous ?

    Qu'en pensez-vous ?

    Voir aussi

    PHP 7.4 devrait être rendu disponible vers la fin de cette année. Voici un aperçu des nouveautés qui pourraient y figurer

    PHP 8 va proposer un compilateur Just In Time qui devrait produire une amélioration des performances en vitesse

    PHP 7.2 est disponible en version stable avec la bibliothèque de cryptographie Sodium et d'autres améliorations et nouvelles fonctionnalités
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Invité
    Invité(e)
    Par défaut
    Très curieux de voir l'impact effectif des weakmaps sur l'utilisation mémoire en général.

    J'aime également beaucoup le travail sur la cohérence qui a commencé avec PHP7, peut être que nous aurons un jour une syntaxe (camel case vs snake case, singulier vs pluriel) et un ordre de paramètres (needle et haystack c'est au petit bonheur la chance actuellement) stable.

  3. #3
    Expert confirmé Avatar de Zefling
    Homme Profil pro
    Développeur Web
    Inscrit en
    avril 2007
    Messages
    1 118
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : avril 2007
    Messages : 1 118
    Points : 4 330
    Points
    4 330
    Par défaut
    Citation Envoyé par Mrsky Voir le message
    Très curieux de voir l'impact effectif des weakmaps sur l'utilisation mémoire en général.

    J'aime également beaucoup le travail sur la cohérence qui a commencé avec PHP7, peut être que nous aurons un jour une syntaxe (camel case vs snake case, singulier vs pluriel) et un ordre de paramètres (needle et haystack c'est au petit bonheur la chance actuellement) stable.
    J'ai l'impression que ce qui est objet est en « camel case » et ce qui est en « procédural » est snake case. Mais je me trompe peut-être.

    C'est vrai que pour les ordres des paramètres, ça fait parfois un peu amateur.

    Pour le reste, je trouve que depuis PHP 7, c'est devenu de plus en plus agréable à utiliser (ce n'est pas que ça me déplaisait avant non plus, mais c'est mieux maintenant).

  4. #4
    Membre averti
    Homme Profil pro
    Un Poste
    Inscrit en
    septembre 2005
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Un Poste
    Secteur : Service public

    Informations forums :
    Inscription : septembre 2005
    Messages : 274
    Points : 380
    Points
    380
    Par défaut
    PHP a sacrément évolué depuis le temps. Que de chemins parcouru...

  5. #5
    Futur Membre du Club
    Homme Profil pro
    Ingénieur commercial
    Inscrit en
    août 2013
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Ingénieur commercial
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : août 2013
    Messages : 1
    Points : 5
    Points
    5
    Par défaut test php8
    Tenez nosu au courant, on fera un benchmark public !

  6. #6
    Membre du Club
    Homme Profil pro
    Développeur Web
    Inscrit en
    février 2010
    Messages
    30
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : février 2010
    Messages : 30
    Points : 66
    Points
    66
    Par défaut
    J'aime également beaucoup le travail sur la cohérence qui a commencé avec PHP7, peut être que nous aurons un jour une syntaxe (camel case vs snake case, singulier vs pluriel) et un ordre de paramètres (needle et haystack c'est au petit bonheur la chance actuellement) stable.
    Ça a déjà été proposé à mainte reprises et je ne penses pas que ça arrivera !
    La "seule" choses qu'on peut espéré est l'ajout de méthode au type scalaire (genre "hello"->length() etc ...)

    Tenez nosu au courant, on fera un benchmark public !
    Il existe déjà une plateforme qui fait des benchmark publique : http://www.phpbenchmarks.com/fr/ (bon ils doivent encore fournir PHP 7.4 mais l'intention y est ! )

  7. #7
    Invité
    Invité(e)
    Par défaut
    C'était complètement impensable avant php7 de standardiser l'ordre des paramètres, et aujourd'hui encore je doute que ce soit faisable.

    Mais a force de dépréciations et de temps on y viendra peut être. Après c'est un peu chiant mais rien d'insurmontable non plus.

  8. #8
    Membre confirmé
    Homme Profil pro
    Développeur Web
    Inscrit en
    janvier 2016
    Messages
    137
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur Web

    Informations forums :
    Inscription : janvier 2016
    Messages : 137
    Points : 502
    Points
    502
    Par défaut
    Citation Envoyé par Cryde Voir le message
    La "seule" choses qu'on peut espéré est l'ajout de méthode au type scalaire (genre "hello"->length() etc ...)
    J'espère aussi

  9. #9
    Membre actif
    Homme Profil pro
    Responsable production
    Inscrit en
    juin 2012
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Responsable production

    Informations forums :
    Inscription : juin 2012
    Messages : 49
    Points : 217
    Points
    217
    Par défaut
    ... ces objets d'être collectés comme des ordures ...
    Les pauvres. #GoogleTranslate
    Si un développeur ne trouve pas au moins une chose gênante dans son code 6 mois après l'avoir écrit, cela signifie qu'il en est au même niveau qu'il y a 6 mois.

  10. #10
    Futur Membre du Club
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    mars 2014
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Chargé d'affaire

    Informations forums :
    Inscription : mars 2014
    Messages : 6
    Points : 8
    Points
    8
    Par défaut Encore une mise à jour de PHP...?
    Encore une mise à jours de PHP ? A quand une MàJ mensuelle ?
    Vous pensez à tous ceux qui sont obligés (je parle des nombreuses petites entreprises qui ont fait développé leurs site en PHP) et qui doivent se coltiner les mises à jour coûteuses pour que leur site continuent à fonctionner ?
    Ils font joujous ces mecs la ?

  11. #11
    Expert éminent sénior
    Avatar de rawsrc
    Homme Profil pro
    Dev indep
    Inscrit en
    mars 2004
    Messages
    6 142
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Dev indep

    Informations forums :
    Inscription : mars 2004
    Messages : 6 142
    Points : 16 471
    Points
    16 471
    Billets dans le blog
    12
    Par défaut
    @marech_jean

    si tu regardes bien, des mises à jour de PHP il y'en a très régulièrement.
    Le passage à une nouvelle version PHP 5 → PHP 7 → PHP 8, c'est beaucoup plus long : PHP 7 (2015-12) → PHP 8 (2021-09 annoncé).
    Il faut reconnaître que cela laisse le temps de voir venir.
    Sans compter que pleins d'hébergeurs font tourner plusieurs versions de PHP en parallèle (de la plus récente à celles qui ne sont même plus supportées)
    Donc question préjudice, c'est assez limité, non ?

  12. #12
    Futur Membre du Club
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    mars 2014
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Chargé d'affaire

    Informations forums :
    Inscription : mars 2014
    Messages : 6
    Points : 8
    Points
    8
    Par défaut
    Pas si simple que ça! D’abord les hébergeurs (dans mon cas Ionos) font désormais payer (cher) le maintien des anciennes versions. Dans notre cas, notre site en 7.1 à déjà des problèmes pour migrer vers le 7.2. Les modifications effectuées manuellement par nos développeurs ont générés des sources d'erreurs.
    On imagine déjà ce qui va se passer quand il faudra passer à la version 8 ! et ainsi de suite...Une belle machine à cash pour les hébergeurs.

  13. #13
    Expert éminent sénior
    Avatar de rawsrc
    Homme Profil pro
    Dev indep
    Inscrit en
    mars 2004
    Messages
    6 142
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Dev indep

    Informations forums :
    Inscription : mars 2004
    Messages : 6 142
    Points : 16 471
    Points
    16 471
    Billets dans le blog
    12
    Par défaut
    bah je me suis fait une mise à jour de 7.1 vers la 7.3 et sincèrement c'est quand même vachement compatible. Y a 2 ou 3 pétouilles à revoir mais globalement si le code n'a pas été pondu par un goret, c'est largement jouable.
    Là j'entame une mise à jour d'un site de PHP 5.6 vers 7.4 et là par contre, c'est autrement plus ardu, faut dire que la branche 5.6 a 6 ans ! Et puis le site tournait à la base sur une version 5.3 qui elle a 11 ans !
    Avec ces paramètres, c'est plus qu'une simple migration vu les reprises de pavés de code à faire entre les dépréciations, les suppressions, les nouvelles structures de langage... Mais bon cela faisait 6 ans que rien n'avait été fait dessus (quand ça fonctionne, on ne touche pas ).

    Au fait le support prolongé chez ionos se chiffre à combien par mois ?

  14. #14
    Futur Membre du Club
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    mars 2014
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Chargé d'affaire

    Informations forums :
    Inscription : mars 2014
    Messages : 6
    Points : 8
    Points
    8
    Par défaut
    entre 9 et 10 € / mois

  15. #15
    Membre habitué Avatar de greg91
    Homme Profil pro
    Administrateur système
    Inscrit en
    novembre 2007
    Messages
    111
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France

    Informations professionnelles :
    Activité : Administrateur système

    Informations forums :
    Inscription : novembre 2007
    Messages : 111
    Points : 168
    Points
    168
    Par défaut
    Encore une mise à jours de PHP ? A quand une MàJ mensuelle ?
    Vous pensez à tous ceux qui sont obligés (je parle des nombreuses petites entreprises qui ont fait développé leurs site en PHP) et qui doivent se coltiner les mises à jour coûteuses pour que leur site continuent à fonctionner ?
    Ils font joujou ces mecs la ?
    C'est pas faux mais d'un autre coté si le langage n'évolue pas quel sera son avenir ?
    Il aurai bien fait d'allonger le support sécu de 5.6, j'héberge beaucoup de sites dont c'est la version max.

  16. #16
    Membre à l'essai
    Homme Profil pro
    Administrateur Base de Donnees
    Inscrit en
    décembre 2015
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : Centrafrique

    Informations professionnelles :
    Activité : Administrateur Base de Donnees
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2015
    Messages : 6
    Points : 12
    Points
    12
    Par défaut Encouragement de l'equipe de developpement
    Selon moi la nouvelle version de php nous donnera plus de posibilite de pouvoir faire de script sans faille securite dans le developpement avec l'integration du nouveu compilateur est vraiiment genial.J'encourage l'equipe a vraiment mettre a notre disposition le plus rapide cette version.

  17. #17
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    6 375
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 6 375
    Points : 154 908
    Points
    154 908
    Par défaut PHP 8 est disponible et s'accompagne de nouvelles fonctionnalités incluant les arguments nommés
    PHP 8 est disponible et s'accompagne de nouvelles fonctionnalités et d'optimisations, incluant les arguments nommés
    les types d'union, l'opérateur nullsafe, la compilation JIT

    PHP 7.4 a été publié en décembre dernier et l’équipe de développement du langage a présenté la nouvelle version majeure PHP 8. Nous y retrouvons entre autres :
    • de nouvelles fonctionnalités :
      • un compilateur JIT ;
      • les « union types » ;
      • les attributs ;
      • une nouvelle classe WeakMap ;
      • les simplifications de code apportées par les nouveaux constructeurs ;
    • de nouvelles fonctions :
      • des changements qui auront un impact sur le code existant (Breaking changes) ;
      • la gestion de l’incrémentation d’index négatifs dans les tableaux ;
      • des modifications sur la gestion des erreurs ;
      • des modifications sur les valeurs par défaut des directives d’initialisation de PHP ;
      • des fonctions supprimées.

    Cette version contient donc beaucoup de nouvelles fonctionnalités et d'optimisations, incluant les arguments nommés, les types d'union, attributs, promotion de propriétés de constructeur, l'expression match, l'opérateur nullsafe, JIT (Compilation à la Volée), et des améliorations dans le système de typage, la gestion d'erreur, et de cohérence.

    Compilation juste à temps (JIT)

    PHP 8 introduit deux moteurs de compilation JIT (juste à temps/compilation à la volée). Le Tracing JIT, le plus prometteur des deux, montre environ trois fois plus de performances sur des benchmarks synthétiques et 1,5-2 fois plus de performances sur certaines applications à longue durée d'exécution. Généralement les performances des applications sont identiques à PHP 7.4.

    Nom : php.png
Affichages : 86548
Taille : 18,6 Ko
    Contribution relative du JIT à la performance de PHP 8

    Amélioration du système de typage et de la gestion d'erreur
    • vérification de type plus sévère pour les opérateurs arithmétiques et bit à bit ;
    • validation de méthode abstraite des traits ;
    • signature valide des méthodes magiques ;
    • reclassifications des avertissements du moteur ;
    • erreur fatale pour des signatures de méthodes incompatibles ;
    • l'opérateur @ ne silence plus les erreurs fatales ;
    • héritages avec les méthodes privées ;
    • type mixed ;
    • type de retour static ;
    • types pour les fonctions internes Discussion e-mail ;
    • objets opaques au lieu de ressources pour les extensions Curl, Gd, Sockets, OpenSSL, XMLWriter, et XML.

    Opérateur Nullsafe

    Au lieu de faire des vérifications conditionnelles de nul, vous pouvez utiliser une chaîne d'appel avec le nouvel opérateur nullsafe. Qui lorsque l'évaluation d'un élément de la chaîne échoue, l'exécution de la chaîne complète est terminée et la chaîne entière évaluée à null.

    Ainsi, dans PHP 7 vous aviez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    $country =  null;
     
    if ($session !== null) {
      $user = $session->user;
     
      if ($user !== null) {
        $address = $user->getAddress();
     
        if ($address !== null) {
          $country = $address->country;
        }
      }
    }

    Dans PHP 8 vous avez son équivalent :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    $country = $session?->user?->getAddress()?->country;

    Expression match

    La nouvelle instruction match est similaire à switch et a les fonctionnalités suivantes :
    • Match est une expression, signifiant que son résultat peut être enregistré dans une variable ou retourné ;
    • les branches de match supportent uniquement les expressions d'une seule ligne, et n'a pas besoin d'une déclaration break ;
    • Match fait des comparaisons strictes.

    Ainsi, dans PHP 7 vous aviez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    switch (8.0) {
      case '8.0':
        $result = "Oh no!";
        break;
      case 8.0:
        $result = "This is what I expected";
        break;
    }
    echo $result;
    //> Oh no!

    Et son équivalent en PHP 8

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    echo match (8.0) {
      '8.0' => "Oh no!",
      8.0 => "This is what I expected",
    };
    //> This is what I expected

    Types d'union

    Au lieu d'annotation PHPDoc pour une combinaison de type, vous pouvez utiliser les déclarations de types d'union native qui sont validées lors de l'exécution.

    Ainsi, en PHP 7 vous aviez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
      /** @var int|float */
      private $number;
     
      /**
       * @param float|int $number
       */
      public function __construct($number) {
        $this->number = $number;
      }
    }
     
    new Number('NaN'); // Ok

    Et son équivalent en PHP 8

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    class Number {
      public function __construct(
        private int|float $number
      ) {}
    }
     
    new Number('NaN'); // TypeError

    Promotion de propriétés de constructeur

    Moins de code redondant pour définir et initialiser les propriétés.

    En PHP 7 vous aviez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    class Point {
      public float $x;
      public float $y;
      public float $z;
     
      public function __construct(
        float $x = 0.0,
        float $y = 0.0,
        float $z = 0.0,
      ) {
        $this->x = $x;
        $this->y = $y;
        $this->z = $z;
      }
    }

    En PHP 8 vous avez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    class Point {
      public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
      ) {}
    }

    Attributs

    Au lieu d'annotations PHPDoc, vous pouvez désormais utiliser les métadonnées structurées avec la syntaxe native de PHP.

    En PHP 7 vous aviez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    /**
    * @Route("/api/posts/{id}", methods={"GET", "HEAD"})
    */
    class User
    {

    En PHP 8 vous avez

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    #[Route("/api/posts/{id}", methods: ["GET", "HEAD"])]
    class User
    {

    Nom : php_logo.png
Affichages : 7352
Taille : 17,7 Ko

    Les arguments nommés

    Les arguments nommés permettent de passer des arguments à une fonction en fonction du nom du paramètre, plutôt que de la position du paramètre. Cela rend la signification de l'argument autodocumentée, rend les arguments indépendants de l'ordre et permet de sauter arbitrairement les valeurs par défaut.

    Pour donner un exemple simple :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    //en utilisant des arguments de position: 
    array_fill(0, 100, 50); 
     
    //en utilisant des arguments nommés: 
    array_fill(start_index: 0, num: 100, value: 50);

    L'ordre dans lequel les arguments nommés sont passés n'a pas d'importance. L'exemple ci-dessus les passe dans le même ordre qu'ils sont déclarés dans la signature de la fonction, mais tout autre ordre est également possible :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    array_fill(value: 50, num: 100, start_index: 0);

    Il est possible de combiner des arguments nommés avec des arguments positionnels normaux et il est également possible de ne spécifier que certains des arguments optionnels d'une fonction, quel que soit leur ordre :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    htmlspecialchars($string, double_encode: false); 
    //Revient à la même chose que 
    htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);

    Il y a plusieurs avantages aux arguments nommés.

    Ignorer les valeurs par défaut

    Les arguments nommés vous permettent d'écraser directement uniquement les valeurs par défaut que vous souhaitez modifier. Prenons cet exemple :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    setcookie( 
        name: 'test', 
        expires: time() + 60 * 60 * 2, 
    );

    Sa signature de méthode est en fait la suivante :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    setcookie (  
        string $name,  
        string $value = "",  
        int $expires = 0,  
        string $path = "",  
        string $domain = "",  
        bool $secure = false,  
        bool $httponly = false, 
    ) : bool

    Dans cet exemple, nous n'avions pas besoin de définir $value d'un cookie, mais nous devions définir une heure d'expiration. Les arguments nommés ont rendu cet appel de méthode un peu plus concis.

    Code autodocumenté

    L'avantage de l'autodocumentation du code s'applique même lorsque vous n'ignorez pas les arguments facultatifs. Par exemple, comparez les deux lignes suivantes :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    array_slice($array, $offset, $length, true); 
    // et 
    array_slice($array, $offset, $length, preserve_keys: true);

    Si cet exemple n'était pas écrit en ce moment, un développeur n'aurait pas su ce que fait le quatrième paramètre de array_slice (ou même qu'il existe en premier lieu).

    Initialisation d'objet

    La RFC de promotion des propriétés du constructeur simplifie considérablement la déclaration des classes d'objets de valeur. Pour choisir l'un des exemples de cette RFC :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    // Partie de la représentation PHP AST 
    class ParamNode extends Node { 
        public function __construct( 
            public string $name, 
            public ExprNode $default = null, 
            public TypeNode $type = null, 
            public bool $byRef = false, 
            public bool $variadic = false, 
            Location $startLoc = null, 
            Location $endLoc = null, 
        ) { 
            parent::__construct($startLoc, $endLoc); 
        } 
    }

    Les constructeurs en particulier ont souvent un nombre plus grand que la moyenne de paramètres dont l'ordre n'a pas de signification particulière, et qui sont généralement par défaut. Bien que la promotion du constructeur simplifie la déclaration de classe, elle n'aide pas l'instanciation d'objet réelle.

    Il y a eu plusieurs tentatives pour rendre la construction d'objets plus ergonomique, comme le RFC Object Initializer et le RFC COPA. Cependant, toutes ces tentatives ont été refusées, car elles ne s'intègrent pas bien dans le langage, en raison d'une interaction défavorable avec des constructeurs ou des propriétés non publiques.

    Les arguments nommés résolvent le problème d'initialisation des objets comme un effet secondaire, d'une manière qui s'intègre bien à la sémantique du langage existant.

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    new ParamNode("test", null, null, false, true); 
    // devient: 
    new ParamNode("test", variadic: true); 
     
    new ParamNode($name, null, null, $isVariadic, $passByRef); 
    // ou était-ce ? 
    new ParamNode($name, null, null, $passByRef, $isVariadic); 
    // qui devient 
    new ParamNode($name, variadic: $isVariadic, byRef: $passByRef); 
    // ou 
    new ParamNode($name, byRef: $passByRef, variadic: $isVariadic); 
    // et cela n'a plus d'importance!

    L'avantage des arguments nommés pour l'initialisation des objets est en surface le même que pour les autres fonctions, cela a juste tendance à avoir plus d'importance dans la pratique ici.

    Options sécurisées et documentées

    L'une des solutions de contournement courantes pour le manque d'arguments nommés est l'utilisation d'un tableau d'options. L'exemple précédent pourrait être réécrit pour utiliser un tableau d'options comme suit :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    class ParamNode extends Node { 
        public string $name; 
        public ExprNode $default; 
        public TypeNode $type; 
        public bool $byRef; 
        public bool $variadic; 
     
        public function __construct(string $name, array $options = []) { 
            $this->name = $name; 
            $this->default = $options['default'] ?? null; 
            $this->type = $options['type'] ?? null; 
            $this->byRef = $options['byRef'] ?? false; 
            $this->variadic = $options['variadic'] ?? false; 
     
            parent::__construct( 
                $options['startLoc'] ?? null, 
                $options['endLoc'] ?? null 
            ); 
        } 
    } 
     
    // Usage: 
    new ParamNode($name, ['variadic' => true]); 
    new ParamNode($name, ['variadic' => $isVariadic, 'byRef' => $passByRef]);

    Bien que cela fonctionne, et soit déjà possible aujourd'hui, cela présente de nombreux inconvénients :
    • pour les constructeurs en particulier, cela exclut l'utilisation de la promotion de constructeur ;
    • les options disponibles ne sont pas documentées dans la signature. Vous devez regarder l'implémentation ou phpdoc pour savoir ce qui est pris en charge et quels types il nécessite. Phpdoc ne fournit pas non plus de moyen universellement reconnu de documenter cela ;
    • le type des valeurs d'option n'est pas validé sauf s'il est implémenté manuellement. Dans l'exemple ci-dessus, les types seront en fait validés en raison de l'utilisation de types de propriétés, mais cela ne suivra pas la sémantique PHP habituelle (par exemple, si la déclaration de classe utilise strict_types, les options seront également validées selon strict_types) ;
    • à moins que vous ne fassiez tout votre possible pour vous protéger, le passage d'options inconnues sera validé silencieusement ;
    • l'utilisation d'un tableau d'options nécessite une décision spécifique au moment de l'introduction de l'API. Si vous commencez sans en utiliser un, mais ajoutez ensuite des paramètres facultatifs supplémentaires et réalisez que l'utilisation d'un tableau d'options serait plus propre, vous ne pouvez pas effectuer le changement sans interrompre les utilisateurs d'API existants.

    Les paramètres nommés fournissent les mêmes fonctionnalités que les tableaux d'options, sans aucun des inconvénients.

    Source : PHP
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  18. #18
    Expert confirmé
    Avatar de laurentSc
    Homme Profil pro
    Webmaster débutant perpétuel !
    Inscrit en
    octobre 2006
    Messages
    8 874
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 57
    Localisation : France, Isère (Rhône Alpes)

    Informations professionnelles :
    Activité : Webmaster débutant perpétuel !
    Secteur : Industrie

    Informations forums :
    Inscription : octobre 2006
    Messages : 8 874
    Points : 4 315
    Points
    4 315
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par rawsrc Voir le message
    si le code n'a pas été pondu par un goret
    Ca veut dire, pas par LaurentSc
    Il vaut mieux viser la perfection et la manquer que viser l'imperfection et l'atteindre. - Bertrand Russell

  19. #19
    Modérateur
    Avatar de grunk
    Homme Profil pro
    Architecte Web / Android
    Inscrit en
    août 2003
    Messages
    6 388
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Architecte Web / Android
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 388
    Points : 18 565
    Points
    18 565
    Par défaut
    Les promotions d'argument de constructeur j'aime pas.
    Les arguments nommé ont plein d'avantage , mais offre aussi la possibilité d'un beau bordel dans le code (genre appeler une fonction avec les arguments jamais dans le même sens) , ca va demander de la rigeur.

    Le reste c'est plein de belles évolutions.

    Et j'avais pas vu , mais PHP se modernise même dans les changelog : https://www.php.net/releases/8.0/fr.php?lang=fr !
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  20. #20
    Membre régulier
    Homme Profil pro
    Inscrit en
    décembre 2004
    Messages
    208
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Savoie (Rhône Alpes)

    Informations forums :
    Inscription : décembre 2004
    Messages : 208
    Points : 92
    Points
    92
    Par défaut
    Citation Envoyé par djimtolouma Voir le message
    Selon moi la nouvelle version de php nous donnera plus de posibilite de pouvoir faire de script sans faille securite dans le developpement avec l'integration du nouveu compilateur est vraiiment genial.J'encourage l'equipe a vraiment mettre a notre disposition le plus rapide cette version.
    Dans les versions 7.2.x à 7.4.x tu peux déjà utiliser des requêtes préparés pour éviter de faire des injections SQL

    L'opérateur @ ne silence plus les erreurs fatales.
    ça dans certains scripts que j'utilise c'est utilisé à la pelle

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo