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.2.0 RC1 est disponible et apporte les propriétés "en lecture seule" aux classes


Sujet :

Langage PHP

  1. #1
    Chroniqueur Actualités
    Avatar de Bruno
    Homme Profil pro
    Rédacteur technique
    Inscrit en
    mai 2019
    Messages
    1 016
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Rédacteur technique
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : mai 2019
    Messages : 1 016
    Points : 20 660
    Points
    20 660
    Par défaut PHP 8.2.0 RC1 est disponible et apporte les propriétés "en lecture seule" aux classes
    PHP 8.2 apportera de nouvelles fonctionnalités et les améliorations de performances,
    annoncée pour la fin de 2022

    PHP 8.2 sera probablement publié à la fin de 2022, mais aucune date n'a encore été fixée. De nouvelles fonctionnalités, les améliorations de performances, les modifications et les dépréciations sont attendues.

    Les techniquement null et false pourraient être considérés comme des types valides par eux-mêmes. Les exemples courants sont les fonctions intégrées de PHP, où false est utilisé comme type de retour en cas d'erreur. Par exemple, dans file_get_contents :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    file_get_contents(/* … */): string|false
    Nom : PHP.png
Affichages : 129128
Taille : 6,9 Ko

    Notons que l'utilisation de false dans un type union était déjà possible ; mais en PHP 8.2, il peut être utilisé comme un type autonome :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    function alwaysFalse(): false
    {
        return false;
    }

    Selon Brent Roose, de nombreux développeurs, dont lui-même, sont un peu méfiants en regardant la RFC qui traite de True et False. « Elle ne prend pas en charge true en tant que type autonome, et les types ne devraient-ils pas représenter des catégories plutôt que des valeurs individuelles ? », s’interroge-t-il. « Il s'avère qu'il existe un concept appelé type unitaire dans les systèmes de types, qui sont des types qui ne permettent qu'une seule valeur. Mais est-ce vraiment utile, et est-ce que cela encourage la conception de logiciels propres ? Peut-être, peut-être pas. », ajoute-til. Un type null autonome est un peu plus logique : null peut être considéré comme une catégorie en soi et pas seulement comme une valeur dans une catégorie.

    Modèle d'objet null

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Post 
    {
        public function getAuthor(): ?string { /* … */ }
    }
     
    class NullPost extends Post
    {
        public function getAuthor(): null { /* … */ }
    }

    Il est logique que NullPost::getAuthor() puisse dire qu'il ne retournera jamais que null, au lieu de null ou string, ce qui n'était pas possible auparavant.

    Brent Roose recommande d’éviter d'utiliser false comme un type autonome pour transmettre un état d'erreur « je pense qu'il y a de meilleures solutions pour résoudre de tels problèmes. »

    Dépréciation des propriétés dynamiques

    Les propriétés dynamiques sont dépréciées en PHP 8.2, et lèveront une ErrorException en PHP 9.0. Rappelons que les propriétés dynamiques sont des propriétés qui ne sont pas présentes sur un objet, mais qui sont néanmoins définies ou obtenues :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class Post
    {
        public string $title;
    }
     
    // …
     
    $post->name = 'Name';

    Les classes implémentant __get et __set fonctionneront toujours comme prévu :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Post
    {
        private array $properties = [];
     
        public function __set(string $name, mixed $value): void
        {
            $this->properties[$name] = $value;
        }
    }
     
    // …
     
    $post->name = 'Name';

    Pour Brent Roose, le PHP était autrefois un langage très dynamique, mais il s'est éloigné de cet état d'esprit depuis un certain temps déjà. Ce dernier pense que c'est une bonne chose d'adopter des règles plus strictes et de s'appuyer sur l'analyse statique partout où cela est possible, car cela permet aux développeurs d'écrire un meilleur code.

    Redact les paramètres dans les traces

    Une pratique courante dans toute base de code est d'envoyer les erreurs de production à un service qui en garde la trace et notifie les développeurs lorsque quelque chose ne va pas. Cette pratique implique souvent l'envoi de traces de pile par câble à un service tiers. Il y a cependant des cas où ces traces de pile peuvent inclure des informations sensibles telles que des variables d'environnement, des mots de passe ou des noms d'utilisateur.

    PHP 8.2 permet de marquer ces « paramètres sensibles » avec un attribut, de sorte que l'utilisateur n'ait pas à se soucier de leur présence dans les piles de traces lorsque quelque chose ne va pas. Voici un exemple tiré de la RFC :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    function test(
        $foo,
        #[SensitiveParameter] $bar,
        $baz
    ) {
        throw new Exception('Error');
    }
     
    test('foo', 'bar', 'baz');
    Fatal error: Uncaught Exception: Error in test.php:8
    Stack trace:
    #0 test.php(11): test('foo', Object(SensitiveParameterValue), 'baz')
    #1 {main}
    thrown in test.php on line 8


    Dépréciation partielle supportée par les callables

    Un autre changement, bien qu'ayant un impact légèrement plus faible, est que les callablespartiellement supportés sont maintenant dépréciés également. Les callables partiellement supportés sont des callables qui peuvent être appelés en utilisant call_user_func($callable), mais pas en appelant $callable() directement. La liste de ces types de callablesest assez courte, d'ailleurs :
    • "self::method"
    • "parent::method"
    • "static::method"
    • ["self", "method"]
    • ["parent", "method"]
    • ["static", "method"]
    • ["Foo", "Bar::method"]
    • [new Foo, "Bar::method"]


    La raison de ce choix ? Pour certains programmeurs, il s'agit là d'un pas dans la bonne direction vers la possibilité d'utiliser callable pour les propriétés typées. C'est bien expliqué dans la RFC :

    « tous ces callables sont dépendants du contexte. La méthode à laquelle self::method fait référence dépend de la classe à partir de laquelle l'appel ou la vérification de callability est effectué. En pratique, cela vaut également pour les deux derniers cas, lorsqu'ils sont utilisés sous la forme [new Foo, "parent::method"].

    La réduction de la dépendance contextuelle des callables est l'objectif secondaire de ce RFC. Après cette RFC, la seule dépendance de portée qui reste est la visibilité de la méthode : Foo::bar peut être visible dans une portée, mais pas dans une autre. Si les callables devaient être limités aux méthodes publiques à l'avenir (tandis que les méthodes privées devraient utiliser des callables de première classe ou Closure::fromCallable() pour être rendues indépendantes de la portée), alors le type callable deviendrait bien défini et pourrait être utilisé comme un type de propriété. Cependant, les modifications de la gestion de la visibilité ne sont pas proposées dans le cadre de ce RFC. »

    Source : Brent Roose's blog

    Et vous ?

    Quel commentaires posez vous sur cette analye de Brent Roose, Programmeur PHP ?

    Voir aussi :

    PhpStorm 2021.3 est disponible avec la prise en charge complète de PHP 8.1, une meilleure gestion des génériques PHP, le développement à distance et bien d'autres améliorations

    JetBrains lance le programme d'accès anticipé (EAP) à PhpStorm 2022.1, la première mise à jour majeure de l'année de son EDI pour le développement Web avec PHP

    La première version EAP de PhpStorm 2021.3 est disponible : prise en charge complète de PHP 8.1 et bien d'autres améliorations et nouveautés

    La version 2021.2 de PhpStorm, l'EDI de JetBrains pour le développement Web avec PHP, est disponible : tour d'horizon des nouveautés et améliorations
    Contribuez au club : corrections, suggestions, critiques, ... Contactez le service news et Rédigez des actualités

  2. #2
    Membre actif Avatar de polkduran
    Profil pro
    Consultant informatique
    Inscrit en
    décembre 2009
    Messages
    155
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2009
    Messages : 155
    Points : 275
    Points
    275
    Par défaut ça existe toujours PHP !
    Mince

  3. #3
    Expert éminent sénior

    Homme Profil pro
    Directeur des systèmes d'information
    Inscrit en
    avril 2002
    Messages
    2 639
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : Luxembourg

    Informations professionnelles :
    Activité : Directeur des systèmes d'information
    Secteur : Finance

    Informations forums :
    Inscription : avril 2002
    Messages : 2 639
    Points : 17 784
    Points
    17 784
    Par défaut
    PHP c'est toujours la technologie Web numéro 1 en France quoi qu'on en dise, et même au niveau mondial : PHP conserve la première place en tant que langage de programmation côté serveur sur le Web avec près de 79% d'utilisation .

    Après PHP avec un Framework genre Laravel ou Symfony ça reste tout à fait utilisable en entreprise, et c'est ce qui se passe
    Ne prenez pas la vie au sérieux, vous n'en sortirez pas vivant ...

  4. #4
    Expert éminent
    Avatar de Séb.
    Profil pro
    Inscrit en
    mars 2005
    Messages
    4 244
    Détails du profil
    Informations personnelles :
    Âge : 44
    Localisation : France

    Informations professionnelles :
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : mars 2005
    Messages : 4 244
    Points : 6 236
    Points
    6 236
    Billets dans le blog
    4
    Par défaut
    PHP ne plait évidemment pas aux consultants qui vendent du Java
    Un problème exposé clairement est déjà à moitié résolu
    Keep It Smart and Simple

  5. #5
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    7 135
    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 : 7 135
    Points : 172 026
    Points
    172 026
    Par défaut PHP 8.2 est disponible en bêta 2. Cette version propose null, true et false en tant que types autonomes
    PHP 8.2 est disponible en bêta 2. Cette version propose null, true et false en tant que types autonomes
    ainsi que des constantes dans les traits

    Depuis le 4 août, la bêta 2 de PHP 8.2 est disponible. La bêta 3 est attendue pour le 18 août et une série de 6 RC va débuter le 1er septembre pour s'achever le 10 novembre. PHP 8.2 sera en disponibilité générale le 24 novembre 2022.

    Nom : date.png
Affichages : 53295
Taille : 6,8 Ko

    Savoir à quoi s’attendre peut vous aider à vous préparer à la dernière version de PHP. En vous renseignant sur les nouvelles fonctionnalités et celles obsolètes, vous pouvez comprendre comment la mise à jour peut affecter votre développement. Cette connaissance peut également vous aider à vous préparer pour la sortie éventuelle.

    Dans cette optique, passons en revue les fonctionnalités, les améliorations de performances, les modifications et les dépréciations.

    De PHP 8.0 à PHP 8.1

    Il est important de savoir à quelles modifications s’attendre avant la mise à niveau.

    PHP 8.0

    PHP 8.0, sorti en novembre 2020, a apporté une poignée de fonctionnalités essentielles. En plus des améliorations de la syntaxe et des performances, la version comprenait :
    • Des arguments nommés
    • la syntaxe de correspondance
    • les types de syndicats
    • Promotion Propriété Constructeur
    • JIT (qui affecte la façon dont PHP exécute le code source)

    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.

    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.

    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.

    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

    Nom : point un.png
Affichages : 2829
Taille : 104,1 Ko

    PHP 8.1

    Un an plus tard est arrivé PHP 8.1, la dernière version majeure de PHP. Cette mise à jour comprend des fonctionnalités importantes, telles que :
    • Types d’intersections
    • Propriétés en lecture seule
    • Énumérations
    • le type de retour never

    Les énumérations ou « Enums » permettent à un développeur de définir un type personnalisé limité à l'une des valeurs possibles parmi un nombre discret. Cela peut être particulièrement utile lors de la définition d'un modèle de domaine, car cela permet de « rendre les états invalides non représentables ».

    Les énumérations apparaissent dans de nombreux langages avec une variété de fonctionnalités différentes. En PHP, les Enums sont un type particulier d'objet. L'Enum lui-même est une classe et ses cas possibles sont tous des objets à instance unique de cette classe. Cela signifie que les cas Enum sont des objets valides et peuvent être utilisés partout où un objet peut être utilisé, y compris les vérifications de type.

    L'exemple le plus populaire d'énumérations est le type booléen intégré, qui est un type énuméré avec les valeurs légales true et false. Les énumérations permettent aux développeurs de définir leurs propres énumérations arbitrairement robustes.

    Dans PHP 8.1, les énumérations sont limitées aux « énumérations d'unités », c'est-à-dire aux énumérations qui sont elles-mêmes une valeur, plutôt qu'une simple syntaxe sophistiquée pour une constante primitive, et n'incluent pas d'informations associées supplémentaires. Cette capacité offre une prise en charge considérablement étendue de la modélisation des données, des définitions de types personnalisées et du comportement de style monade. Les énumérations permettent la technique de modélisation consistant à « rendre les états invalides non représentables », ce qui conduit à un code plus robuste avec moins de tests exhaustifs.

    Les responsables du langage recommandent d'utiliser les énumérations au lieu d'un ensemble de constantes et d'obtenir ainsi une validation prête à l'emploi.

    Par exemple, avant PHP 8.1, vous pouviez écrire :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    class Status 
    { 
        const DRAFT = 'draft'; 
        const PUBLISHED = 'published'; 
        const ARCHIVED = 'archived'; 
    } 
    function acceptStatus(string $status) {...}

    Ce code est optimisé en PHP 8.1 avec les énumérations :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    enum Status 
    { 
        case Draft; 
        case Published; 
        case Archived; 
    } 
    function acceptStatus(Status $status) {...}

    Propriétés en lecture seule readonly : Les objets valeur sont souvent immuables : les propriétés sont initialisées une fois dans le constructeur et ne doivent pas être modifiées par la suite. PHP n'a actuellement aucun moyen d'appliquer cette contrainte. L'alternative la plus proche consiste à déclarer la propriété private et à n'exposer qu'un getter public

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class User { 
        public function __construct( 
            private string $name 
        ) {} 
     
        public function getName(): string { 
            return $this->name; 
        } 
    }

    Cela ne rend pas réellement la propriété en lecture seule, mais cela resserre la portée où une modification pourrait se produire sur une seule déclaration de classe. Malheureusement, cela nécessite l'utilisation d'un passe-partout getter, ce qui entraîne une moins bonne ergonomie.

    La prise en charge des propriétés en lecture seule de première classe vous permet d'exposer directement les propriétés publiques en lecture seule, sans craindre que les invariants de classe puissent être rompus par une modification externe :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    class User { 
        public function __construct( 
            public readonly string $name 
        ) {} 
    }

    Aussi, cette proposition a été retenue : une propriété en lecture seule ne peut être initialisée qu'une seule fois, et uniquement à partir de la portée où elle a été déclarée. Toute autre affectation ou modification de la propriété entraînera une exception d'erreur.

    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
    class Test { 
        public readonly string $prop; 
     
        public function __construct(string $prop) { 
            // Legal initialization. 
            $this->prop = $prop; 
        } 
    } 
     
    $test = new Test("foobar"); 
    // Legal read. 
    var_dump($test->prop); // string(6) "foobar" 
     
    // Illegal reassignment. It does not matter that the assigned value is the same. 
    $test->prop = "foobar"; 
    // Error: Cannot modify readonly property Test::$prop

    La suite concerne PHP 8.2.

    null, true et false en tant que types autonomes (Release Candidate)

    PHP 8.2 ajoute trois nouveaux types — ou quelque chose qui y ressemble. Techniquement null, true et false pourraient être considérés comme des types valides en eux-mêmes. Des exemples courants sont les fonctions intégrées de PHP, où false est utilisé comme type de retour lorsqu'une erreur se produit. Par exemple dans file_get_contents*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    file_get_contents(/* … */): string|false

    Avant PHP 8.2, vous pouviez déjà utiliser false avec d'autres types comme union ; mais maintenant, il peut également être utilisé comme type autonome*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    function alwaysFalse(): false
    {
        return false;
    }

    Il en va de même pour true et null.

    Classes en lecture seule (RFC)

    Les propriétés en lecture seule ont été introduites dans PHP 8.1. Cette RFC s'appuie sur eux et ajoute du sucre syntaxique pour rendre toutes les propriétés de classe en lecture seule à la fois. Au lieu d'écrire ceci :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Post
    {
        public function __construct(
            public readonly string $title, 
            public readonly Author $author,
            public readonly string $body,
            public readonly DateTime $publishedAt,
        ) {}
    }

    Vous pouvez maintenant écrire ceci :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    readonly class Post
    {
        public function __construct(
            public string $title, 
            public Author $author,
            public string $body,
            public DateTime $publishedAt,
        ) {}
    }

    Fonctionnellement, rendre une classe en lecture seule est entièrement identique à rendre chaque propriété en lecture seule ; mais cela empêchera également l'ajout de propriétés dynamiques sur une classe*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    $post = new Post(/* … */);
     
    $post->unknown = 'wrong';

    Citation Envoyé par Résultat
    Uncaught Error: Cannot create dynamic property Post::$unknown
    Déprécier les propriétés dynamiques (rfc)

    En parlant de propriétés dynamiques*: c'est un changement pour le mieux, mais cela fera un peu mal. Les propriétés dynamiques sont obsolètes en PHP 8.2 et lèveront une ErrorException en PHP 9.0. Que sont les propriétés dynamiques, demandez-vous*? Ce sont des propriétés qui ne sont pas présentes sur un objet, mais qui sont néanmoins définies ou obtenues*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class Post
    {
        public string $title;
    }
     
    // …
     
    $post->name = 'Name';

    Gardez à l'esprit que les classes implémentant __get et __set fonctionneront toujours comme prévu*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Post
    {
        private array $properties = [];
     
        public function __set(string $name, mixed $value): void
        {
            $this->properties[$name] = $value;
        }
    }
     
    // …
     
    $post->name = 'Name';

    Il en va de même pour les objets de stdClass, ils continueront à prendre en charge les propriétés dynamiques.

    Il est indéniable qu'il y a des développeurs qui se sont appuyés sur des propriétés dynamiques et qui ne sont pas satisfaits de ce changement. Mais l'équipe pense que ces développeurs gagneraient à approfondir l'analyse statique.

    Et juste au cas où vous ne voudriez pas ces avertissements lors de la mise à niveau vers PHP 8.2, vous pouvez faire plusieurs choses.

    Vous pouvez utiliser l'attribut #[AllowDynamicProperties] sur les classes qui doivent toujours autoriser ces propriétés*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    #[AllowDynamicProperties]
    class Post
    {
        public string $title;
    }
     
    // …
     
    $post->name = 'Name'; // All fine

    Ou vous pouvez simplement désactiver les avertissements d'obsolescence. Cela n'est pas recommandé, car vous aurez des problèmes avec PHP 9.0, mais voici comment désactiver les avertissements de dépréciation en PHP :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    error_reporting(E_ALL ^ E_DEPRECATED);

    Types de forme normale disjonctive (DNF pour Disjunctive Normal Form) en RFC

    Les types DNF nous permettent de combiner les types d'union et d'intersection, en suivant une règle stricte*: lors de la combinaison de types d'union et d'intersection, les types d'intersection doivent être regroupés avec des crochets. En pratique, cela ressemble à ceci :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function generateSlug((HasTitle&HasId)|null $post) 
    {
        if ($post === null) {
            return '';
        }
     
        return 
            strtolower($post->getTitle()) 
            . $post->getId();
    }

    Dans ce cas, (HasTitle&HasId)|null est le type DNF.

    C'est un ajout intéressant, d'autant plus que cela signifie que nous pouvons désormais avoir des types d'intersection nullables, ce qui est probablement le cas d'utilisation le plus important pour cette fonctionnalité.

    Constantes dans les traits (rfc)

    Vous pouvez désormais utiliser des constantes dans les traits*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    trait Foo 
    {
        public const CONSTANT = 1;
     
        public function bar(): int 
        {
            return self::CONSTANT;
        }
    }

    Vous ne pourrez pas accéder à la constante via le nom du trait, ni de l'extérieur du trait, ni de l'intérieur de celui-ci.

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    trait Foo 
    {
        public const CONSTANT = 1;
     
        public function bar(): int 
        {
            return Foo::CONSTANT;
        }
    }
     
    Foo::CONSTANT;

    Vous pouvez cependant accéder à la constante via la classe qui utilise le trait, étant donné qu'elle est publique*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    class MyClass
    {
        use Foo;
    }
     
    MyClass::CONSTANT; // 1

    Source : PHP

    Voir aussi :

    PHP 8 est disponible et s'accompagne d'optimisations et de nouvelles fonctionnalités, incluant entre autres les arguments nommés, les types d'union, l'opérateur nullsafe, la compilation JIT
    PHP 8.1 est disponible. Cette version permet d'obtenir une référence à n'importe quelle fonction et apporte le type de retour never
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  6. #6
    Nouveau membre du Club
    Profil pro
    Inscrit en
    mai 2007
    Messages
    36
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2007
    Messages : 36
    Points : 32
    Points
    32
    Par défaut
    Bonjour, pensez-vous que c'est une bonne idée d'apprendre le PHP à l'heure actuelle ? Je vois la popularité de PHP qui décline peu à peu au fil des années (index TIOBE par ex.) et j'ai peur que d'ici une dizaine d'années, ce langage devienne marginal comme l'est devenu le Perl. Je suis inquiet d'investir beaucoup d'énergie et de me lancer sur des années d'apprentissage pour un langage amené à décliner. Qu'en pensez-vous ?

  7. #7
    Expert éminent
    Avatar de Séb.
    Profil pro
    Inscrit en
    mars 2005
    Messages
    4 244
    Détails du profil
    Informations personnelles :
    Âge : 44
    Localisation : France

    Informations professionnelles :
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : mars 2005
    Messages : 4 244
    Points : 6 236
    Points
    6 236
    Billets dans le blog
    4
    Par défaut
    Perl a toujours été un langage de niche. Je minquieterai pour PHP le jour où d'autres langages/technos permettront de mettre en œuvre du web aussi facilement.
    À l'heure actuelle, et à mon sens, son seul réel concurrent à ce niveau est une stack Node, mais JS & cie c'est la jungle et une remise en cause quotidienne.
    Et puis, comme pour tout langage, c'est le principe qui compte. Si tu adoptes PHP, 1. ça ne te demandera pas spécifiquement des années d'apprentissage et 2. l'expérience engrangée te permettra de passer facilement sur une autre techno au besoin. Donc oui, apprend PHP, apprend les bonnes pratiques, apprend à bien structurer tes projets (Laravel/Symfony), ne t'enferme pas dans des trucs comme Wordpress, et garde en tête que PHP n'est pas destiné qu'au web (on peut faire du CLI aussi par ex.).
    Un problème exposé clairement est déjà à moitié résolu
    Keep It Smart and Simple

  8. #8
    Nouveau membre du Club
    Profil pro
    Inscrit en
    mai 2007
    Messages
    36
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2007
    Messages : 36
    Points : 32
    Points
    32
    Par défaut
    Intéressant... Merci Séb. pour avoir partagé ton avis, oui, c'est vrai, ça se tient.

  9. #9
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    7 135
    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 : 7 135
    Points : 172 026
    Points
    172 026
    Par défaut PHP 8.2.0 RC1 est disponible et apporte les propriétés "en lecture seule" aux classes,
    PHP 8.2.0 RC1 est disponible et apporte les propriétés "en lecture seule" aux classes,
    ainsi que la possibilité de déprécier les propriétés dynamiques

    Depuis le 1er septembre, l'équipe responsable du développement de PHP a annoncé la disponibilité de PHP 8.2.0 RC1, conformément à son calendrier. La RC2 est attendue le 15 septembre. Il y en aura six au total, la sixième étant attendue le 10 novembre. PHP 8.2 sera en disponibilité générale le 24 novembre 2022

    Savoir à quoi s’attendre peut vous aider à vous préparer à la dernière version de PHP. En vous renseignant sur les nouvelles fonctionnalités et celles obsolètes, vous pouvez comprendre comment la mise à jour peut affecter votre développement. Cette connaissance peut également vous aider à vous préparer pour la sortie éventuelle.

    Dans cette optique, passons en revue les fonctionnalités, les améliorations de performances, les modifications et les dépréciations.

    De PHP 8.0 à PHP 8.1

    Il est important de savoir à quelles modifications s’attendre avant la mise à niveau.

    PHP 8.0

    PHP 8.0, sorti en novembre 2020, a apporté une poignée de fonctionnalités essentielles. En plus des améliorations de la syntaxe et des performances, la version comprenait :
    • Des arguments nommés
    • la syntaxe de correspondance
    • les types de syndicats
    • Promotion Propriété Constructeur
    • JIT (qui affecte la façon dont PHP exécute le code source)

    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.

    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.

    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.

    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

    Nom : point un.png
Affichages : 15199
Taille : 104,1 Ko

    PHP 8.1

    Un an plus tard est arrivé PHP 8.1, la dernière version majeure de PHP. Cette mise à jour comprend des fonctionnalités importantes, telles que :
    • Types d’intersections
    • Propriétés en lecture seule
    • Énumérations
    • le type de retour never

    Les énumérations ou « Enums » permettent à un développeur de définir un type personnalisé limité à l'une des valeurs possibles parmi un nombre discret. Cela peut être particulièrement utile lors de la définition d'un modèle de domaine, car cela permet de « rendre les états invalides non représentables ».

    Les énumérations apparaissent dans de nombreux langages avec une variété de fonctionnalités différentes. En PHP, les Enums sont un type particulier d'objet. L'Enum lui-même est une classe et ses cas possibles sont tous des objets à instance unique de cette classe. Cela signifie que les cas Enum sont des objets valides et peuvent être utilisés partout où un objet peut être utilisé, y compris les vérifications de type.

    L'exemple le plus populaire d'énumérations est le type booléen intégré, qui est un type énuméré avec les valeurs légales true et false. Les énumérations permettent aux développeurs de définir leurs propres énumérations arbitrairement robustes.

    Dans PHP 8.1, les énumérations sont limitées aux « énumérations d'unités », c'est-à-dire aux énumérations qui sont elles-mêmes une valeur, plutôt qu'une simple syntaxe sophistiquée pour une constante primitive, et n'incluent pas d'informations associées supplémentaires. Cette capacité offre une prise en charge considérablement étendue de la modélisation des données, des définitions de types personnalisées et du comportement de style monade. Les énumérations permettent la technique de modélisation consistant à « rendre les états invalides non représentables », ce qui conduit à un code plus robuste avec moins de tests exhaustifs.

    Les responsables du langage recommandent d'utiliser les énumérations au lieu d'un ensemble de constantes et d'obtenir ainsi une validation prête à l'emploi.

    Par exemple, avant PHP 8.1, vous pouviez écrire :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    class Status 
    { 
        const DRAFT = 'draft'; 
        const PUBLISHED = 'published'; 
        const ARCHIVED = 'archived'; 
    } 
    function acceptStatus(string $status) {...}

    Ce code est optimisé en PHP 8.1 avec les énumérations :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    enum Status 
    { 
        case Draft; 
        case Published; 
        case Archived; 
    } 
    function acceptStatus(Status $status) {...}

    Propriétés en lecture seule readonly : Les objets valeur sont souvent immuables : les propriétés sont initialisées une fois dans le constructeur et ne doivent pas être modifiées par la suite. PHP n'a actuellement aucun moyen d'appliquer cette contrainte. L'alternative la plus proche consiste à déclarer la propriété private et à n'exposer qu'un getter public

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class User { 
        public function __construct( 
            private string $name 
        ) {} 
     
        public function getName(): string { 
            return $this->name; 
        } 
    }

    Cela ne rend pas réellement la propriété en lecture seule, mais cela resserre la portée où une modification pourrait se produire sur une seule déclaration de classe. Malheureusement, cela nécessite l'utilisation d'un passe-partout getter, ce qui entraîne une moins bonne ergonomie.

    La prise en charge des propriétés en lecture seule de première classe vous permet d'exposer directement les propriétés publiques en lecture seule, sans craindre que les invariants de classe puissent être rompus par une modification externe :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    class User { 
        public function __construct( 
            public readonly string $name 
        ) {} 
    }

    Aussi, cette proposition a été retenue : une propriété en lecture seule ne peut être initialisée qu'une seule fois, et uniquement à partir de la portée où elle a été déclarée. Toute autre affectation ou modification de la propriété entraînera une exception d'erreur.

    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
    class Test { 
        public readonly string $prop; 
     
        public function __construct(string $prop) { 
            // Legal initialization. 
            $this->prop = $prop; 
        } 
    } 
     
    $test = new Test("foobar"); 
    // Legal read. 
    var_dump($test->prop); // string(6) "foobar" 
     
    // Illegal reassignment. It does not matter that the assigned value is the same. 
    $test->prop = "foobar"; 
    // Error: Cannot modify readonly property Test::$prop

    La suite concerne PHP 8.2.

    null, true et false en tant que types autonomes (Release Candidate)

    PHP 8.2 ajoute trois nouveaux types — ou quelque chose qui y ressemble. Techniquement null, true et false pourraient être considérés comme des types valides en eux-mêmes. Des exemples courants sont les fonctions intégrées de PHP, où false est utilisé comme type de retour lorsqu'une erreur se produit. Par exemple dans file_get_contents:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    file_get_contents(/* … */): string|false

    Avant PHP 8.2, vous pouviez déjà utiliser false avec d'autres types comme union ; mais maintenant, il peut également être utilisé comme type autonome :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    function alwaysFalse(): false
    {
        return false;
    }

    Il en va de même pour true et null.

    Classes en lecture seule (RFC)

    Les propriétés en lecture seule ont été introduites dans PHP 8.1. Cette RFC s'appuie sur eux et ajoute du sucre syntaxique pour rendre toutes les propriétés de classe en lecture seule à la fois. Au lieu d'écrire ceci :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Post
    {
        public function __construct(
            public readonly string $title, 
            public readonly Author $author,
            public readonly string $body,
            public readonly DateTime $publishedAt,
        ) {}
    }

    Vous pouvez maintenant écrire ceci :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    readonly class Post
    {
        public function __construct(
            public string $title, 
            public Author $author,
            public string $body,
            public DateTime $publishedAt,
        ) {}
    }

    Fonctionnellement, rendre une classe en lecture seule est entièrement identique à rendre chaque propriété en lecture seule ; mais cela empêchera également l'ajout de propriétés dynamiques sur une classe*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    $post = new Post(/* … */);
     
    $post->unknown = 'wrong';

    Citation Envoyé par Résultat
    Uncaught Error: Cannot create dynamic property Post::$unknown
    Déprécier les propriétés dynamiques (rfc)

    En parlant de propriétés dynamiques : c'est un changement pour le mieux, mais cela fera un peu mal. Les propriétés dynamiques sont obsolètes en PHP 8.2 et lèveront une ErrorException en PHP 9.0. Que sont les propriétés dynamiques, demandez-vous*? Ce sont des propriétés qui ne sont pas présentes sur un objet, mais qui sont néanmoins définies ou obtenues :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class Post
    {
        public string $title;
    }
     
    // …
     
    $post->name = 'Name';

    Gardez à l'esprit que les classes implémentant __get et __set fonctionneront toujours comme prévu :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class Post
    {
        private array $properties = [];
     
        public function __set(string $name, mixed $value): void
        {
            $this->properties[$name] = $value;
        }
    }
     
    // …
     
    $post->name = 'Name';

    Il en va de même pour les objets de stdClass, ils continueront à prendre en charge les propriétés dynamiques.

    Il est indéniable qu'il y a des développeurs qui se sont appuyés sur des propriétés dynamiques et qui ne sont pas satisfaits de ce changement. Mais l'équipe pense que ces développeurs gagneraient à approfondir l'analyse statique.

    Et juste au cas où vous ne voudriez pas ces avertissements lors de la mise à niveau vers PHP 8.2, vous pouvez faire plusieurs choses.

    Vous pouvez utiliser l'attribut #[AllowDynamicProperties] sur les classes qui doivent toujours autoriser ces propriétés :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    #[AllowDynamicProperties]
    class Post
    {
        public string $title;
    }
     
    // …
     
    $post->name = 'Name'; // All fine

    Ou vous pouvez simplement désactiver les avertissements d'obsolescence. Cela n'est pas recommandé, car vous aurez des problèmes avec PHP 9.0, mais voici comment désactiver les avertissements de dépréciation en PHP :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    error_reporting(E_ALL ^ E_DEPRECATED);

    Types de forme normale disjonctive (DNF pour Disjunctive Normal Form) en RFC

    Les types DNF nous permettent de combiner les types d'union et d'intersection, en suivant une règle stricte*: lors de la combinaison de types d'union et d'intersection, les types d'intersection doivent être regroupés avec des crochets. En pratique, cela ressemble à ceci :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function generateSlug((HasTitle&HasId)|null $post) 
    {
        if ($post === null) {
            return '';
        }
     
        return 
            strtolower($post->getTitle()) 
            . $post->getId();
    }

    Dans ce cas, (HasTitle&HasId)|null est le type DNF.

    C'est un ajout intéressant, d'autant plus que cela signifie que nous pouvons désormais avoir des types d'intersection nullables, ce qui est probablement le cas d'utilisation le plus important pour cette fonctionnalité.

    Constantes dans les traits (rfc)

    Vous pouvez désormais utiliser des constantes dans les traits*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    trait Foo 
    {
        public const CONSTANT = 1;
     
        public function bar(): int 
        {
            return self::CONSTANT;
        }
    }

    Vous ne pourrez pas accéder à la constante via le nom du trait, ni de l'extérieur du trait, ni de l'intérieur de celui-ci.

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    trait Foo 
    {
        public const CONSTANT = 1;
     
        public function bar(): int 
        {
            return Foo::CONSTANT;
        }
    }
     
    Foo::CONSTANT;

    Vous pouvez cependant accéder à la constante via la classe qui utilise le trait, étant donné qu'elle est publique*:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    class MyClass
    {
        use Foo;
    }
     
    MyClass::CONSTANT; // 1

    Ces quelques améliorations et corrections accompagnent la RC1 :

    CLI*:
    • Implémenter un serveur Web intégré répondant sans corps à la requête HEAD sur une ressource statique.
    • Implémenter un serveur Web intégré répondant avec le statut HTTP 405 à la requête DELETE/PUT/PATCH sur une ressource statique.


    Cœur:
    • Correction du bug GH-9323 (Crash dans ZEND_RETURN/GC/zend_call_function)
    • Correction du bogue GH-9227 (les points de fin et les espaces dans les noms de fichiers sont ignorés).
    • Correction du bug GH-9285 (les traits ne peuvent pas être utilisés dans les classes en lecture seule).
    • Correction du bogue GH-9186 (@strict-properties peut être contourné en utilisant la désérialisation).

    Date:
    • Correction du bogue GH-9431 (DateTime :: getLastErrors() ne renvoyant pas false en l'absence d'erreurs/avertissements).


    OpenSSL*:
    • Correction du bogue GH-9310 (SSL local_cert et local_pk ne respectent pas open_basedir).
    • Implémenter FR #76935 ("chacha20-poly1305" est un AEAD mais ne fonctionne pas comme AEAD).
    • Ajout de la fonction openssl_cipher_key_length.


    Source : PHP

    Voir aussi :

    PHP 8 est disponible et s'accompagne d'optimisations et de nouvelles fonctionnalités, incluant entre autres les arguments nommés, les types d'union, l'opérateur nullsafe, la compilation JIT
    PHP 8.1 est disponible. Cette version permet d'obtenir une référence à n'importe quelle fonction et apporte le type de retour never
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  10. #10
    Membre régulier Avatar de selmanjo
    Homme Profil pro
    Apprentis en programmation orienté objet
    Inscrit en
    janvier 2020
    Messages
    42
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Apprentis en programmation orienté objet
    Secteur : Conseil

    Informations forums :
    Inscription : janvier 2020
    Messages : 42
    Points : 77
    Points
    77
    Par défaut
    J'ai bien aimé le " match " qu'on retrouve dans pas mal de langages

Discussions similaires

  1. Réponses: 27
    Dernier message: 04/12/2020, 10h52
  2. Réponses: 1
    Dernier message: 16/09/2020, 09h35
  3. Réponses: 0
    Dernier message: 20/04/2019, 23h00
  4. Réponses: 4
    Dernier message: 17/08/2006, 16h25

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