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 :

Les arguments nommés vont débarquer dans PHP 8 et promettent d'apporter de nombreux avantages


Sujet :

Langage PHP

  1. #1
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    6 300
    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 300
    Points : 154 479
    Points
    154 479
    Par défaut Les arguments nommés vont débarquer dans PHP 8 et promettent d'apporter de nombreux avantages
    Les arguments nommés vont débarquer dans PHP 8 et promettent d'apporter de nombreux avantages,
    d'écraser directement uniquement les valeurs par défaut que vous souhaitez modifier

    La source de PHP 8.0 est prévue pour la fin de cette année avec un ambitieux programme, notamment :
    • 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.

    Il y a quelques jours, la communauté PHP a adopté les named arguments (arguments nommés), aussi appelé named parameters (paramètres 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);

    Cette fonctionnalité a fait l'objet de vives discussions et des contre-arguments ont été avancés pour ne pas l'implémenter.

    L'un des arguments contre les paramètres nommés est qu'ils rendraient difficile la maintenance d'un logiciel open source : changer le nom d'un argument deviendrait un changement radical. Voici ce que cela signifie. Imaginez un package open source qui a cette fonction dans le cadre de son API publique:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    public function toMediaCollection(string $collection, string $disk = null);

    Les paramètres nommés permettraient d'appeler cette fonction comme ceci:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    $pendingMedia
        ->toMediaCollection(collection: 'downloads', disk: 's3');

    Si, pour une raison quelconque, le mainteneur souhaite changer le nom de la variable $collection ou $disk, il devra taguer une version majeure, car des arguments nommés en feraient un changement radical.

    Nom : Brent.png
Affichages : 81909
Taille : 15,0 Ko

    Quels sont les avantages des arguments nommés ?

    Ignorer les valeurs par défaut

    Cependant, pour plusieurs développeurs, les avantages l'emportent de loin sur la peur des problèmes de compatibilité ascendante ou des API gonflées. Certains pensent même qu'ils permettront d'écrire un code plus propre et plus flexible. D'une part, les arguments nommés vous permettent d'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. Ci-dessous setcookie sans les arguments nommés puis avec les arguments nommés:

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

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

    Code auto-documenté

    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'objet 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

    Les attributs

    L'utilisation d'arguments nommés dans les annotations phpdoc est déjà largement répandue dans l'écosystème. Bien que la RFC Attributes remplace les annotations phpdoc par une fonctionnalité de langage de première classe, elle ne prend pas en charge les arguments nommés. Cela signifie que les annotations existantes devront introduire des changements structurels importants pour migrer vers le système d'attributs.

    Par exemple, l'annotation Symfony Route accepte un certain nombre d'options facultatives telles que des méthodes. Actuellement, une migration vers des attributs peut ressembler à ceci:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    /**
     * @Route("/api/posts/{id}", methods={"GET","HEAD"})
     */
    public function show(int $id) { ... }
     
    // Might become:
     
    <<Route("/api/posts/{id}", ["methods" => ["GET", "HEAD"]])>>
    public function show(int $id) { ... }

    L'introduction d'arguments nommés dans la même version que les attributs permettrait de conserver exactement la même structure qu'auparavant:

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    <<Route("/api/posts/{id}", methods: ["GET", "HEAD"])>>
    public function show(int $id) { ... }

    Certaines modifications seraient encore nécessaires en raison du manque de prise en charge des annotations imbriquées, mais cela rendrait la migration un peu plus fluide.

    Source : PHP

    Et vous ?

    Que pensez-vous des arguments nommés ?

    Voir aussi :

    Les nouveautés de PHP 8
    Microsoft annonce qu'il ne va plus offrir de support à PHP sur Windows dès la version 8.0 dont la sortie est prévue pour novembre
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  2. #2
    Membre régulier
    Homme Profil pro
    Développeur Web
    Inscrit en
    décembre 2011
    Messages
    72
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2011
    Messages : 72
    Points : 107
    Points
    107
    Par défaut
    Présenté comme ça l'est dans cet article, ça semble être une évolution très positive. Les tableaux d'options sont toujours une plaie à gérer, la source de nombreux problème et de code illisible.

    Par contre je suis un peu plus dubitatif sur la forme que vont prendre les attributs. Je les trouve beaucoup moins lisibles que les annotations symfony par exemple. A voir sur la durée...

  3. #3
    Membre éclairé
    Femme Profil pro
    Inscrit en
    juillet 2012
    Messages
    227
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : Italie

    Informations forums :
    Inscription : juillet 2012
    Messages : 227
    Points : 806
    Points
    806
    Par défaut
    super ce PHP 8! j'aimerai faire tout avec le php, du compilé aussi, des gui crossplatform...

  4. #4
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    décembre 2011
    Messages
    9 014
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 28
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : décembre 2011
    Messages : 9 014
    Points : 22 931
    Points
    22 931
    Par défaut
    <troll>C'est pas déjà mort le PHP ?</troll>

  5. #5
    Membre extrêmement actif
    Profil pro
    Inscrit en
    juin 2010
    Messages
    753
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2010
    Messages : 753
    Points : 912
    Points
    912
    Par défaut
    Citation Envoyé par emilie77 Voir le message
    super ce PHP 8! j'aimerai faire tout avec le php, du compilé aussi, des gui crossplatform...
    En fait c'était possible à une époque en bindant php sur dotnet, le projet s'appelait https://fr.wikipedia.org/wiki/Phalanger_(compilateur)

    De nos jours il est possible de faire tourner php "par dessus" dotnet core avec le compilateur peachpie les gains en performance et en sécurité sont simplement astronomique.

  6. #6
    Modérateur
    Avatar de grunk
    Homme Profil pro
    Architecte Web / Android
    Inscrit en
    août 2003
    Messages
    6 368
    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 368
    Points : 18 487
    Points
    18 487
    Par défaut
    J'y vois 2 intérêts :
    - la possibilité de sauter facilement de nombreux arguments optionnels et pour ca c'est très bien.
    - c'est la solution de facilité pour PHP afin de se débarrasser de ses incohérences dans les ordres de paramètres.

    Mais de l'autre coté :
    - ca va rendre le code plus verbeux (je désactive d'ailleurs cette fonctionnalité dans les ide intellij)
    - Les problème de rétrocompatibilité risque d'être important
    - Le mélange d'appel entre argument nommés ou positionnels va faire mal au crane ...
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  7. #7
    Nouveau membre du Club
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    novembre 2017
    Messages
    6
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : novembre 2017
    Messages : 6
    Points : 25
    Points
    25
    Par défaut
    Citation Envoyé par NoPr0n
    Présenté comme ça l'est dans cet article, ça semble être une évolution très positive. Les tableaux d'options sont toujours une plaie à gérer, la source de nombreux problème et de code illisible.

    Par contre je suis un peu plus dubitatif sur la forme que vont prendre les attributs. Je les trouve beaucoup moins lisibles que les annotations symfony par exemple. A voir sur la durée...
    Le caractère "@" ne peut pas être utilisé directement à cause de sa signification en PHP (il sert à rendre une erreur silencieuse et renvoyer false).
    C'est vraiment plus un soucis technique du côté interpréteur PHP qui par volonté.
    Les syntaxes "@@(...)" et "#[...]" ont été proposées également (et il me semble que des votes sont encore en cours).

    Citation Envoyé par Neckara
    <troll>C'est pas déjà mort le PHP ?</troll>
    C'est toujours la première techno sur le web en terme de sites servis, je crois
    Donc... non ?

  8. #8
    Membre à l'essai
    Inscrit en
    décembre 2009
    Messages
    14
    Détails du profil
    Informations forums :
    Inscription : décembre 2009
    Messages : 14
    Points : 11
    Points
    11
    Par défaut
    Je pense directement au langage Python

  9. #9
    Futur Membre du Club
    Homme Profil pro
    Enseignant
    Inscrit en
    mars 2013
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Enseignant
    Secteur : Enseignement

    Informations forums :
    Inscription : mars 2013
    Messages : 1
    Points : 9
    Points
    9
    Par défaut simplification de la gestion des paramètres des fonctions en PHP
    une astuce simple avec toutes les versions de PHP
    https://www.developpez.net/forums/bl...fonctions-php/

Discussions similaires

  1. mettre les argument de la fonction dans la formule de la cellule
    Par patricktoulon dans le forum Macros et VBA Excel
    Réponses: 8
    Dernier message: 17/07/2016, 10h46
  2. Réponses: 18
    Dernier message: 02/02/2016, 23h11
  3. [XL-2007] verifier les arguments d'une fonction dans une boucle
    Par patricktoulon dans le forum Macros et VBA Excel
    Réponses: 2
    Dernier message: 26/10/2012, 14h55
  4. Récuperer les arguments d'une méthode dans un tableau/Arraylist
    Par Boudj94 dans le forum Collection et Stream
    Réponses: 4
    Dernier message: 21/01/2011, 14h00
  5. Réponses: 5
    Dernier message: 02/07/2008, 14h10

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