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.1 est disponible. Cette version permet d'obtenir une référence à n'importe quelle fonction


Sujet :

Langage PHP

  1. #1
    Chroniqueur Actualités

    Homme Profil pro
    Rédacteur technique
    Inscrit en
    juin 2016
    Messages
    2 388
    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 388
    Points : 47 236
    Points
    47 236
    Par défaut PHP 8.1 est disponible. Cette version permet d'obtenir une référence à n'importe quelle fonction
    PHP 8.1 : restriction de l'utilisation de $GLOBALS, notation littérale octale explicite des entiers,
    voici un aperçu des nouveautés attendues dans la prochaine version du langage

    Alors que PHP 8 a été publié en novembre dernier, l'équipe de développement du langage travaille déjà sur la prochaine version mineure, notamment PHP 8.1. Comme chaque version de PHP, PHP 8.1 ajoute de nouvelles fonctionnalités au langage, fait quelques modifications, rend certaines fonctions obsolètes et déprécie certaines fonctions obsolètes depuis les versions précédentes. Voici ci-dessus quelques fonctionnalités connues qui pourraient être livrées avec PHP 8.1. Notez que cette nouvelle version est en cours de développement, alors d'autres fonctionnalités pourraient s'ajouter jusqu'à la date de publication, qui sera probablement en novembre.

    Nouvelles fonctionnalités dans PHP 8.1

    Déballage des tableaux (Array unpacking) avec des clés de chaîne

    Le déballage de tableaux était déjà autorisé en PHP 7.4, mais il ne fonctionnait qu'avec des clés numériques. La raison pour laquelle les clés de chaînes n'étaient pas supportées auparavant est qu'il n'y avait pas de consensus sur la façon de fusionner les doublons de tableaux. Cette RFC résout ce problème en suivant la sémantique de "array_merge" :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    $array1 = ["a" => 1];
    
    $array2 = ["b" => 2];
    
    $array = ["a" => 0, ...$array1, ...$array2];
    
    var_dump($array); // ["a" => 1, "b" => 2]
    Nouvelle fonction array_is_list

    Vous avez probablement déjà eu à faire face à cette situation de temps en temps : déterminer si les clés d'un tableau sont dans l'ordre numérique, en commençant par l'index 0. Tout comme "json_encode" décide si un tableau doit être encodé comme un tableau ou un objet, PHP 8.1 ajoute une fonction intégrée pour déterminer si un tableau est une liste avec cette sémantique, ou non. En d'autres termes, cette fonction retourne "true" si le tableau donné est une liste sémantique de valeurs ; un tableau où toutes les clés sont des entiers, les clés commencent à 0, sans aucun espace entre elles. La fonction "array_is_list" renvoie également la valeur "true" pour les tableaux vides.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    $list = ["a", "b", "c"];
    
    array_is_list($list); // true
    
    $notAList = [1 => "a", 2 => "b", 3 => "c"];
    
    array_is_list($notAList); // false
    
    $alsoNotAList = ["a" => "a", "b" => "b", "c" => "c"];
    
    array_is_list($alsoNotAList); // false
    Notation littérale octale explicite des entiers

    PHP prend en charge divers systèmes de numération, notamment le système décimal par défaut (base 10), le système binaire (base 2), le système octal (base 8) et le système hexadécimal (base 16). Les systèmes numériques autres que décimaux sont préfixés par leur propre préfixe :

    • Hex avec préfixe 0x : par exemple 0x11 = 17 ;
    • Binaire avec préfixe 0b : par exemple 0b11 = 3 ;
    • Octal avec le préfixe 0 : par exemple 011 = 9.

    Vous pouvez maintenant utiliser 0o pour désigner les nombres octal. En effet, à partir de PHP 8.1 et pour les versions ultérieures, les chiffres octaux supportent aussi le préfixe 0o (zéro, suivi de o), ce qui signifie que les littéraux numériques octaux sont désormais rendus plus évidents et plus lisibles. Le 0O (zéro, suivi d'un O majuscule comme dans Oscar) est également pris en charge. En outre, la notation précédente en préfixant un nombre par un 0 pour indiquer qu'il s'agit d'un nombre octal fonctionne toujours aussi bien.

    Enums

    Cette RFC introduit les énumérations dans le langage PHP. Le champ d'application de cette RFC est limité 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 fantaisiste pour une constante primitive, et qui n'incluent pas d'informations supplémentaires associées. Cette capacité offre une prise en charge considérablement élargie pour la modélisation des données, les définitions de types personnalisés et le comportement de type monade.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    enum Status {
      case Pending;
      case Active;
      case Archived;
    }
    Les énumérations permettent la technique de modélisation consistant à "rendre les états non valides non représentables", ce qui permet d'obtenir un code plus robuste et de réduire les besoins en tests exhaustifs. Les dénombrements sont construits sur la base de classes et d'objets. Cela signifie que, sauf indication contraire, "comment les Enums se comporteraient dans la situation X" peut être répondu "de la même manière que toute autre instance d'objet". Ils passeraient, par exemple, un contrôle de type d'objet.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Post
    {
        public function __construct(
            private Status $status = Status::Pending;
        ) {}
    
        public function setStatus(Status $status): void
        {
            // …
        }
    }
    
    $post->setStatus(Status::Active);
    Les noms des Enums ne sont pas sensibles à la casse, mais sont soumis à la même mise en garde concernant l'autochargement sur les systèmes de fichiers sensibles à la casse que celle qui s'applique déjà aux classes en général. Les noms de casse sont implémentés en interne comme des constantes de classe, et sont donc sensibles à la casse. Toutefois, cette RFC est toujours en cours de discussion. Même s'il n'y a pas encore eu de vote, cette proposition d'ajouter des énumérations a été reçue avec enthousiasme. L'ajout d'énumérations pourrait être une amélioration significative de PHP.

    Changements de rupture

    Bien que PHP 8.1 soit une version mineure, il y aura quelques changements qui pourraient techniquement être un changement de rupture, et des déprédations aussi. En voici quelques-uns.

    Restreindre l'utilisation de $GLOBALS

    La variable $GLOBALS fournit actuellement une référence directe à la table de symboles interne de PHP. La prise en charge de cette fonction nécessite une grande complexité technique, affecte les performances de toutes les opérations de tableau dans PHP, mais n'est que rarement utilisée. Cette RFC restreint les utilisations supportées de $GLOBALS afin de rejeter les cas problématiques, tout en permettant à la plupart du code de continuer à fonctionner tel quel. L'idée centrale de cette proposition est de faire passer $GLOBALS de variable "réelle" à sémantique non standard à une variable syntaxique à deux sémantiques :

    • les accès de la forme $GLOBALS [$var] feront référence à la variable globale $ $var, et supporteront toutes les opérations habituelles de la variable, y compris les écritures. $GLOBALS [$var] = la valeur $ reste supportée. Une bonne façon d'y penser est que $GLOBALS[$var] fonctionne de la même manière qu'une variable $ $var, en accédant simplement à la portée globale au lieu de la portée locale ;
    • les accès de la forme $GLOBALS (sans déréférencement direct du tableau) renverront une copie en lecture seule du tableau de symboles global.

    Une petite modification de la manière dont $GLOBALS est utilisé aura un impact significatif sur les performances de toutes les opérations de la matrice.

    Déprécier le passage de null à des arguments non annulables des fonctions internes

    Les fonctions internes (définies par PHP ou ses extensions) acceptent actuellement de manière silencieuse des valeurs nulles pour les arguments non annulables en mode de frappe coercitif. Ceci est contraire au comportement des fonctions définies par l'utilisateur, qui n'acceptent que les valeurs nulles pour les arguments nuls. Cette RFC vise à résoudre cette incohérence. Voici ci-dessous de quoi il s'agit :

    Si

    • la nullité est passée à l'argument d'une fonction interne ;
    • l'argument n'est pas annulable ;
    • l'argument accepte au moins un type scalaire (un de bool, int, float ou string) ;
    • le mode de frappe coercitif est utilisé, c'est-à-dire que strict_types=1 n'est pas activé ;


    alors

    • en PHP < 8.1, la valeur nulle sera silencieusement contrainte à false, 0, 0.0 ou "" ;
    • en PHP >= 8.1, une erreur de dépréciation est lancée, mais la valeur est toujours contrainte et l'appel a toujours lieu ;
    • en PHP >= 9.0, une erreur de type (TypeError) sera déclenchée, en accord avec le comportement des fonctions définies par l'utilisateur.

    Source : RFC PHP 8.1

    Et vous ?

    Que pensez-vous des fonctionnalités prévues pour être livrées avec PHP 8.1 ?
    Quelles fonctionnalités aimeriez-vous voir apparaître dans cette version ?

    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

    Les nouveautés de PHP 8 - Sortie de la version alpha 1 prévue le 25 juin 2020 ! Par Alexandre Tranchant

    PHP 7.4.0 est disponible avec de nombreuses améliorations et de nouvelles fonctionnalités, telles que les propriétés typées, un séparateur numérique littéral, et autres

    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
    Modérateur
    Avatar de grunk
    Homme Profil pro
    Lead dév - Architecte
    Inscrit en
    août 2003
    Messages
    6 542
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Côte d'Or (Bourgogne)

    Informations professionnelles :
    Activité : Lead dév - Architecte
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 542
    Points : 19 346
    Points
    19 346
    Par défaut
    Etrange cette utilisation du case sur la syntaxe des énums
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  3. #3
    Expert confirmé
    Avatar de Séb.
    Profil pro
    Inscrit en
    mars 2005
    Messages
    4 115
    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 115
    Points : 5 944
    Points
    5 944
    Billets dans le blog
    2
    Par défaut
    Bizarre aussi d'accepter le 0O en plus du 0o pour débuter la notation octale. Quelqu'un ne connaissant pas la subtilité peut y perdre des heures s'il ne remarque pas le O.
    Un problème exposé clairement est déjà à moitié résolu
    Keep It Smart and Simple

  4. #4
    Membre éprouvé
    Homme Profil pro
    retraité
    Inscrit en
    septembre 2014
    Messages
    427
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : retraité

    Informations forums :
    Inscription : septembre 2014
    Messages : 427
    Points : 1 049
    Points
    1 049
    Par défaut
    Citation Envoyé par grunk Voir le message
    Etrange cette utilisation du case sur la syntaxe des énums
    En effet.
    En Pascal, les énumérations existent depuis le début !
    Exemple :

    Code Pascal : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    type
      TFruits = (Orange, Pomme, Banane, Peche, Pasteque, Pamplemousse);
    type
      TCorbeilleDeFruits = set of TFruits;
     
     
    var
      fruit: TFruits;
    begin
      for fruit := low(TFruits) to high(TFruits) do
      begin
        ShowMessage(GetEnumName(typeinfo(TFruits), ord(fruit)));
      end;
    end;

  5. #5
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    6 839
    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 839
    Points : 157 818
    Points
    157 818
    Par défaut PHP 8.1 est disponible. Cette version permet d'obtenir une référence à n'importe quelle fonction
    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

    PHP 8.1 est une mise à jour majeure du langage PHP. Il contient de nombreuses nouvelles fonctionnalités, notamment des énumérations, des propriétés en lecture seule, une syntaxe appelable de première classe, des fibres, des types d'intersection, des améliorations de performances, etc.

    Énumérations

    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 nombreuses 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 recommande 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

    Cette variante n'est pas autorisée, car l'affectation d'initialisation se fait depuis l'extérieur de la classe :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class Test {
        public readonly string $prop;
    }
     
    $test = new Test;
    // Illegal initialization outside of private scope.
    $test->prop = "foobar";
    // Error: Cannot initialize readonly property Test::$prop from global scope

    Les modifications ne sont pas nécessairement des affectations simples, tous les éléments suivants entraîneront également 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
    17
    class Test {
        public function __construct(
            public readonly int $i = 0,
            public readonly array $ary = [],
        ) {}
    }
     
    $test = new Test;
    $test->i += 1;
    $test->i++;
    ++$test->i;
    $test->ary[] = 1;
    $test->ary[0][] = 1;
    $ref =& $test->i;
    $test->i =& $ref;
    byRef($test->i);
    foreach ($test as &$prop);

    Cependant, les propriétés en lecture seule n'excluent pas la mutabilité intérieure. Les objets (ou ressources) stockés dans des propriétés en lecture seule peuvent toujours être modifiés en interne :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Test {
        public function __construct(public readonly object $obj) {}
    }
     
    $test = new Test(new stdClass);
    // Legal interior mutation.
    $test->obj->foo = 1;
    // Illegal reassignment.
    $test->obj = new stdClass;

    Restrictions

    Le modificateur readonly ne peut être appliqué qu'aux propriétés typées. La raison en est que les propriétés non typées ont une valeur par défaut nulle implicite, qui compte comme une affectation d'initialisation et causerait probablement de la confusion.

    Grâce à l'introduction du type mixte dans PHP 8.0, une propriété en lecture seule sans contraintes de type peut être créée en utilisant le type mixte :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    class Test {
        public readonly mixed $prop;
    }

    L'alternative serait de ne pas utiliser de valeur par défaut nulle implicite pour les propriétés en lecture seule non typées. Cependant, cela rendrait les règles pour les valeurs par défaut des propriétés implicites plus complexes et déroutantes. Le simple fait d'en faire une condition d'erreur permet au développeur de s'inscrire explicitement en spécifiant le type mixte.

    Nom : php.png
Affichages : 71386
Taille : 127,9 Ko

    Syntaxe appelable de première classe

    PHP 8.1 introduit une syntaxe appelable de première classe, qui remplace les encodages existants utilisant des chaînes et des tableaux. L'avantage est que la nouvelle syntaxe est accessible à l'analyse statique et respecte la portée au moment où l'appelable est créé.

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    $fn = Closure::fromCallable('strlen');
    $fn = strlen(...);
     
    $fn = Closure::fromCallable([$this, 'method']);
    $fn = $this->method(...)
     
    $fn = Closure::fromCallable([Foo::class, 'method']);
    $fn = Foo::method(...);

    Dans cet exemple, chaque paire d'expressions est équivalente. La syntaxe strlen(...) crée un Closure qui fait référence à la fonction strlen(), et ainsi de suite.

    Le ... peut être vu comme la syntaxe de décompression d'arguments ...$args, avec les arguments réels non encore renseignés :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    $fn = Foo::method(...);
    // Think of it as:
    $fn = fn(...$args) => Foo::method(...$args);

    Aussi, avant PHP 8.1 vous aviez :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    $foo = [$this, 'foo'];
     
    $fn = Closure::fromCallable('strlen');

    À partir de PHP 8.1 vous avez :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    $foo = $this->foo(...);
     
    $fn = strlen(...);

    Il est désormais possible d'obtenir une référence à n'importe quelle fonction - c'est ce qu'on appelle la syntaxe appelable de première classe.

    Expression new dans les initialisateurs

    PHP 8.1 autorise l'utilisation des expressions new dans les valeurs par défaut des paramètres, les arguments d'attribut, les initialiseurs de variables statiques et les initialiseurs de constantes globales.

    Avant cette version, un code tel que celui-ci n'était pas autorisé :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    class Test {
        public function __construct(
            private Logger $logger = new NullLogger,
        ) {}
    }

    Au lieu de cela, il était nécessaire d'écrire ainsi :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Test {
        private Logger $logger;
     
        public function __construct(
            ?Logger $logger = null,
        ) {
            $this->logger = $logger ?? new NullLogger;
        }
    }

    Cela rend la valeur par défaut réelle moins évidente (du point de vue du contrat d'API) et nécessite l'utilisation d'un argument nullable.

    Aussi, les responsables ont accepté la demande d'assouplissement de cette restriction : le langage autorise désormais l'utilisation de new à l'intérieur de certaines expressions d'initialisation.

    Les objets peuvent désormais être utilisés comme valeurs de paramètres par défaut, variables statiques et constantes globales, ainsi que dans les arguments d'attribut.

    Cela permet effectivement d'utiliser des attributs imbriqués.

    Avant PHP 8.1 :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    class User
    {
        /**
         * @Assert\All({
         *     @Assert\NotNull,
         *     @Assert\Length(min=5)
         * })
         */
        public string $name = '';
    }

    Depuis PHP 8.1 :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    class User
    {
        #[\Assert\All(
            new \Assert\NotNull,
            new \Assert\Length(min: 6))
        ]
        public string $name = '';
    }

    Types d'intersection purs

    Un « type d'intersection » nécessite une valeur pour satisfaire plusieurs contraintes de type au lieu d'une seule.

    Avant PHP 8.1, les types d'intersection n'étaient pas pris en charge nativement par le langage. Au lieu de cela, il fallait soit utiliser des annotations phpdoc, et/ou abuser des propriétés typées comme on peut le voir dans l'exemple suivant :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class Test {
        private ?Traversable $traversable = null;
        private ?Countable $countable = null;
        /** @var Traversable&Countable */
        private $both = null;
     
        public function __construct($countableIterator) {
            $this->traversable =& $this->both;
            $this->countable =& $this->both;
            $this->both = $countableIterator;
        }
    }

    La prise en charge des types d'intersection dans le langage permet de déplacer davantage d'informations de type de phpdoc vers les signatures de fonction, avec les avantages habituels que cela apporte :
    • Les types sont effectivement appliqués, de sorte que les erreurs peuvent être détectées tôt.
    • Parce qu'elles sont appliquées, les informations de type sont moins susceptibles de devenir obsolètes ou de manquer des cas limites.
    • Les types sont vérifiés lors de l'héritage, appliquant le principe de substitution de Liskov.
    • Les types sont disponibles via Reflection.
    • La syntaxe est beaucoup moins passe-partout que phpdoc.

    Avant PHP 8.1 :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    function count_and_iterate(Iterator $value) {
        if (!($value instanceof Countable)) {
            throw new TypeError('value must be Countable');
        }
     
        foreach ($value as $val) {
            echo $val;
        }
     
        count($value);
    }

    Depuis PHP 8.1 :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    function count_and_iterate(Iterator&Countable $value) {
        foreach ($value as $val) {
            echo $val;
        }
     
        count($value);
    }

    Cette version permet donc d'utiliser des types d'intersection lorsqu'une valeur doit satisfaire plusieurs contraintes de type en même temps.

    Il n'est actuellement pas possible de mélanger des types d'intersection et d'union tels que A&B|C.

    Le type de retour never

    Une fonction ou une méthode déclarée avec le type never indique qu'elle ne retournera pas de valeur et qu'elle lancera une exception ou terminera l'exécution du script avec un appel de die(), exit(), trigger_error() ou quelque chose de similaire.

    never est disponible à partir de PHP 8.1.0.

    never est, dans le jargon de la théorie des types, le type inférieur. Cela signifie qu'il s'agit du sous-type de tous les autres types et qu'il peut remplacer tout autre type de retour lors de l'héritage.

    Avant PHP 8.1 :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    function redirect(string $uri) {
        header('Location: ' . $uri);
        exit();
    }
     
    function redirectToLoginPage() {
        redirect('/login');
        echo 'Hello'; // <- dead code
    }

    Depuis PHP 8.1 :

    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    function redirect(string $uri): never {
        header('Location: ' . $uri);
        exit();
    }
     
    function redirectToLoginPage(): never {
        redirect('/login');
        echo 'Hello'; // <- dead code detected by static analysis
    }

    Source : PHP

    Et vous ?

    Que pensez-vous des fonctionnalités livrées avec PHP 8.1 ?
    Lesquelles vous intéressent le plus ?
    Quelles fonctionnalités aimeriez-vous voir apparaître dans une future mise à jour ?
    De manière plus globale, comment trouvez vous l'évolution du langage ?

    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
    Les nouveautés de PHP 8 - Sortie de la version alpha 1 prévue le 25 juin 2020 ! Par Alexandre Tranchant
    PHP 7.4.0 est disponible avec de nombreuses améliorations et de nouvelles fonctionnalités, telles que les propriétés typées, un séparateur numérique littéral, et autres
    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

  6. #6
    Membre confirmé Avatar de Gaulouis
    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    octobre 2015
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : France, Paris (Île de France)

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

    Informations forums :
    Inscription : octobre 2015
    Messages : 246
    Points : 472
    Points
    472
    Par défaut T'as pas oublié un "s" ?
    Citation Envoyé par grunk Voir le message
    Etrange cette utilisation du case sur la syntaxe des énums
    Bonjour à tous,

    Pour moi, php 8.1 c'est le version de trop

    Si tu regarde le site officiel de php il y a 2 liens qui pointe vers oracle. Et oracle c'est pas celui qui possède le compte twitter JavaScript Et combien ont investi Oracle & ses amis pour faire Node.JS ?
    Nom : nikita.jpg
Affichages : 5463
Taille : 26,2 Ko


    Avant:
    Code php : Sélectionner tout - Visualiser dans une fenêtre à part
    @$result=$foo->findBar()->getCoca()->pay();

    Aujourd'hui:
    Code php : Sélectionner tout - Visualiser dans une fenêtre à part
    $result=$foo?->findBar()?->getCoca()?->pay();

    Citation Envoyé par Proverbe
    Le sucre ne sert à rien quand c'est le sel qui manque.

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

    Informations professionnelles :
    Activité : Lead dév - Architecte
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 542
    Points : 19 346
    Points
    19 346
    Par défaut
    Citation Envoyé par Gaulouis Voir le message
    Bonjour à tous,

    Avant:
    Code php : Sélectionner tout - Visualiser dans une fenêtre à part
    @$result=$foo->findBar()->getCoca()->pay();

    Aujourd'hui:
    Code php : Sélectionner tout - Visualiser dans une fenêtre à part
    $result=$foo?->findBar()?->getCoca()?->pay();
    L'utilisation de "@" n'a jamais été recommandé , elle ne fait que masquer une erreur , pas la traiter correctement.
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  8. #8
    Membre confirmé Avatar de Gaulouis
    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    octobre 2015
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : France, Paris (Île de France)

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

    Informations forums :
    Inscription : octobre 2015
    Messages : 246
    Points : 472
    Points
    472
    Par défaut Je recommande l'utilisation de "@" pour annoter les dettes technique.
    L'utilisation de "@" n'a jamais été recommandé , elle ne fait que masquer une erreur , pas la traiter correctement.
    Excellent, tu va peut-être m'apprendre un truc.

    En quoi cette nouvelle syntaxe est recommandé ?
    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    $result=$foo?->findBar()?->getCoca()?->pay();

    Comment va-t-elle traiter l'erreur "CoronaException : No such bar open." ou "ExtraException: No coca available."

    Comment ça se concrétise le "démasquage" d'erreur ?

  9. #9
    Membre à l'essai
    Profil pro
    Inscrit en
    juillet 2012
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juillet 2012
    Messages : 10
    Points : 11
    Points
    11
    Par défaut
    Il s'agit ici de simplifier la gestion des retours null.
    Si tu as besoin d'une gestion fine, tu ne passeras pas par ce système.
    Si une exception est levée c'est à toi de l'attraper.

    Bref ca ne change rien à la gestion des exceptions.

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

    Informations professionnelles :
    Activité : Lead dév - Architecte
    Secteur : Industrie

    Informations forums :
    Inscription : août 2003
    Messages : 6 542
    Points : 19 346
    Points
    19 346
    Par défaut
    Citation Envoyé par Gaulouis Voir le message
    Excellent, tu va peut-être m'apprendre un truc.

    En quoi cette nouvelle syntaxe est recommandé ?
    Code PHP : Sélectionner tout - Visualiser dans une fenêtre à part
    $result=$foo?->findBar()?->getCoca()?->pay();

    Comment va-t-elle traiter l'erreur "CoronaException : No such bar open." ou "ExtraException: No coca available."

    Comment ça se concrétise le "démasquage" d'erreur ?
    La syntaxe que tu évoques (opérateur nullsafe) permet juste d'éviter de vérifier l'état null et d'écrire des trucs comme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    if(is_null($foo)) {
    	$result = null;
    } else {
    	$bar = $foo->findBar();
    	if(is_null($bar)) {
    		$result = null;
    	} else {
    		$coca = $bar->getCoca();
    		if(is_null($coca)) {
    			$result = null;
    		} else {
    			$result = $coca->pay();
    		}
    	}
    }
    Si tu as des problématique d'exception , alors il faut les traiter avec un try/catch et certainement pas avec un "@". Ca c'est vrai depuis php 4.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    try {
    	$result = $result=$foo?->findBar()?->getCoca()?->pay();
    } catch(Exception $e) {
    	$result = null;
    }
    Pry Framework php5 | N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  11. #11
    Membre confirmé Avatar de Gaulouis
    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    octobre 2015
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : France, Paris (Île de France)

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

    Informations forums :
    Inscription : octobre 2015
    Messages : 246
    Points : 472
    Points
    472
    Par défaut
    Ok, merci à vous deux, je viens de comprendre.

    Il s'agit ici de simplifier la gestion des retours null.
    @ le faisait déjà sur les propriétés mais pas sur les méthodes.
    Et pour une raison de rétrocompatibilité le choix a été d'ajouter des élément de langage plutôt que de modifier le comportement historique.

  12. #12
    Expert confirmé
    Avatar de Séb.
    Profil pro
    Inscrit en
    mars 2005
    Messages
    4 115
    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 115
    Points : 5 944
    Points
    5 944
    Billets dans le blog
    2
    Par défaut
    @ le faisait déjà sur les propriétés mais pas sur les méthodes.
    Non, @ ne fait que cacher l'erreur et ne change rien à la valeur retournée.
    @ est principalement est utile sur les fonctions d'ouverture de flux difficilement prévisibles et qui émettent un warning, comme fopen(),
    autrement il vaut mieux l'éviter.
    Un problème exposé clairement est déjà à moitié résolu
    Keep It Smart and Simple

  13. #13
    Membre confirmé Avatar de Gaulouis
    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    octobre 2015
    Messages
    246
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : France, Paris (Île de France)

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

    Informations forums :
    Inscription : octobre 2015
    Messages : 246
    Points : 472
    Points
    472
    Par défaut Qu'est ce que j'ai raté ?
    Citation Envoyé par PHP Manual > Language Reference > Operators
    PHP supports one error control operator: the at sign (@). When prepended to an expression in PHP, any diagnostic error that might be generated by that expression will be suppressed.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <?php
     
    class A {
      function findBar() {
        return $this;
      }
      function getCoca() {
        return null;//throw new Exception("is not catchable by '@' or '?'");
      }
      function pay() {
        return 2.50;
      }
    }
     
    $foo = new A;
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    <?php $result = $foo->usualBar->cocaDrink->price;//Warning: Attempt to read property "cocaDrink" on null
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    <?php $result = $foo?->findBar()?->getCoca()->pay();//Fatal error: Call to a member function pay() on null
    Passons les erreurs sous silence:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    <?php @$result = $foo->usualBar->cocaDrink->price;
    var_dump($result);// output null
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    <?php $result = $foo?->findBar()?->getCoca()?->pay();
    var_dump($result);// output null
    J'aurai préféré :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    <?php @$result = $foo->usualBar()->cocaDrink()->price();// mute (Fatal error: Call to undefined method A::usualBar )
    var_dump($result);// output null
    Donc les '?' permetent de passer sous silence des erreur "Uncaught Error" mais pas "@" ... Pourquoi ?

  14. #14
    Expert confirmé
    Avatar de Séb.
    Profil pro
    Inscrit en
    mars 2005
    Messages
    4 115
    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 115
    Points : 5 944
    Points
    5 944
    Billets dans le blog
    2
    Par défaut
    Citation Envoyé par Gaulouis Voir le message
    Donc les '?' permetent de passer sous silence des erreur "Uncaught Error" mais pas "@" ... Pourquoi ?
    Il s'agit d'une exception, et pas d'une erreur ("Uncaught"). @ ne s'occupe que des erreurs. Pour les exceptions il y a try/catch/finally
    Un problème exposé clairement est déjà à moitié résolu
    Keep It Smart and Simple

Discussions similaires

  1. Quoi de neuf dans NetAdvantage 13.1 ?
    Par Hinault Romaric dans le forum Général Dotnet
    Réponses: 0
    Dernier message: 11/04/2013, 16h43
  2. Quoi de neuf dans la version 5.2 de Talend ?
    Par jsd03 dans le forum Talend
    Réponses: 0
    Dernier message: 02/01/2013, 12h00
  3. Visual Studio 2012 : quoi de neuf dans la Release Candidate ?
    Par Hinault Romaric dans le forum Visual Studio
    Réponses: 23
    Dernier message: 11/06/2012, 09h37
  4. Quoi de neuf dans Windows 8 Consumer Preview pour les développeurs ?
    Par Hinault Romaric dans le forum Windows 8
    Réponses: 2
    Dernier message: 16/03/2012, 09h16

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