Type de conseils de propriétés en PHP 7?

N'php 7 type de support les conseils de propriétés de la classe?

Je veux dire, pas juste pour setters/getters mais pour le bien lui-même.

Quelque chose comme:

class Foo {
    /**
     *
     * @var Bar
     */
    public $bar : Bar;
}

$fooInstance = new Foo();
$fooInstance->bar = new NotBar(); //Error

Non pas que je suis au courant de. Cependant, en général toutes les contraintes sur une valeur de la propriété doit être fait par le biais d'un poseur de toute façon. Depuis le setter peut facilement avoir un typehint de la "valeur" d'argument, vous êtes bon pour aller.
De nombreux cadres de là-bas fait d'utiliser des attributs protégés (surtout pour les contrôleurs). Pour ces cas, en particulier, il serait très utile.

InformationsquelleAutor CarlosCarucce | 2016-05-16

93

PHP 7.4 soutiendra des propriétés typées comme suit:
```
class Person
{
    public string $name;
    public DateTimeImmutable $dateOfBirth;
}
```
PHP 7.3 et versions antérieures ne prennent pas en charge cela, mais il ya quelques solutions de rechange.

Vous pouvez faire une propriété privée qui est accessible uniquement par le biais des getters et setters qui ont les déclarations de type:
```
class Person
{
    private $name;
    public function getName(): string {
        return $this->name;
    }
    public function setName(string $newName) {
        $this->name = $newName;
    }
}
```
Vous pouvez aussi faire un bien public et d'utiliser un docblock de fournir des informations de type pour les gens à lire le code et l'utilisation d'un IDE, mais cela ne fournit aucune exécution vérification de type:
```
class Person
{
    /**
      * @var string
      */
    public $name;
}
```
Et en effet, vous pouvez combiner les getters et les setters et un docblock.

Si vous êtes plus aventureux, vous pourriez faire un faux bien avec le __get, __set, __isset et __unset méthodes magiques, et de vérifier les types de vous-même. Je ne suis pas sûr si je le recommande, cependant.
- Sonne vraiment bien. Ne peut pas attendre de voir ce qui est à venir sur les prochaines versions!
- Ugh. Dommage que la RFC a échoué 🙁
- Est-il une explication de cette RFC a été rejeté?
- La représentation de l'impact sur la non-type-allusion classes.
- Elle le suce en sachant que la proposition est rejetée.
- Est-il une chance pour que cette RFC être reconsidérée dans le futur? (Surtout si les problèmes de performances sont atténués.) Il a remporté majorité de 60% de 34 à 23, près de 66% nécessaires. wiki.php.net/rfc/typed-properties
- Une autre question importante est le traitement de référence, ce qui n'a pas vraiment d'interaction avec les déclarations de type et peut être désactivé pour ces propriétés. Même sans les problèmes de performance, de ne pas être capables de faire, de dire, array_push($this->foo, $bar) ou sort($this->foobar) serait une grosse affaire.
- Il y a un nouveau RFC dans les œuvres wiki.php.net/rfc/typed_properties_v2
- Propriétés typées cible de la version de PHP a été modifié, passant de 7,3 à 7,4 et vote va commencer dans les prochains jours
- Il a été accepté pour 7.4 il y a un moment donc j'ai mis à jour cette réponse.
- Grande nouvelle! Merci pour votre mise à jour
- Comment la contrainte de types de travail? Par exemple: (new Person())->dateOfBirth = '2001-01-01';... à Condition de declare(strict_types=0); qui est. Il va les jeter ou de l'utilisation de la DateTimeImmutable constructeur? Et si c'est le cas, quel type d'erreur sera levée si la chaîne est une date non valide? TypeError?
- Il n'y a pas de conversion implicite de type DateTime(Immuable) et ne l'a jamais été
InformationsquelleAutor Andrea
5

7.4+:

Bonne nouvelle qu'il sera mis en œuvre dans les nouvelles versions, comme @Andrea souligné.
Je vais juste laisser cette solution ici au cas où quelqu'un veut l'utiliser avant de 7,4

7.3 ou moins

Sur la base de notifications que je reçois encore de ce fil, je crois que beaucoup de gens y avaient/ont le même problème que j'ai eu. Ma solution pour ce cas a été la combinaison setters + __set méthode magique à l'intérieur d'un trait afin de simuler ce comportement.
Ici, il est:
```
trait SettersTrait
{
    /**
     * @param $name
     * @param $value
     */
    public function __set($name, $value)
    {
        $setter = 'set'.$name;
        if (method_exists($this, $setter)) {
            $this->$setter($value);
        } else {
            $this->$name = $value;
        }
    }
}
```
Et voici la démonstration:
```
class Bar {}
class NotBar {}

class Foo
{
    use SettersTrait; //It could be implemented within this class but I used it as a trait for more flexibility

    /**
     *
     * @var Bar
     */
    private $bar;

    /**
     * @param Bar $bar
     */
    protected function setBar(Bar $bar)
    {
        //(optional) Protected so it wont be called directly by external 'entities'
        $this->bar = $bar;
    }
}

$foo = new Foo();
$foo->bar = new NotBar(); //Error
//$foo->bar = new Bar(); //Success
```
Explication

Tout d'abord, définir bar comme une propriété privée afin de PHP sera jeté __set automatiquement.

__set va vérifier si il y a un setter déclaré dans l'objet courant (method_exists($this, $setter)). Sinon, il ne définissez sa valeur comme il le ferait normalement.

Déclarer une méthode de définition (setBar) qui reçoit un type allusion argument (setBar(Bar $bar)).

Tant que PHP détecte que quelque chose qui n'est pas Bar instance est passé pour le setter, il va automatiquement déclencher une Erreur Fatale: Uncaught TypeError: Argument 1 passé à Toto::setBar() doit être une instance de Bar, de l'instance de NotBar donné

InformationsquelleAutor CarlosCarucce

Il n'est pas réellement possible et vous n'avez 4 possibilités pour réellement simuler :

Valeurs par défaut
Décorateurs dans des blocs de commentaires
Valeurs par défaut dans le constructeur
Getters et setters

J'ai combiné tous ici

class Foo
{
    /**
     * @var Bar
     */
    protected $bar = null;

    /** 
    * Foo constructor
    * @param Bar $bar
    **/
    public function __construct(Bar $bar = null){
        $this->bar = $bar;
    }

    /**
    * @return Bar
    */
    public function getBar() : ?Bar{
        return $this->bar;
    }

    /**
    * @param Bar $bar
    */
    public function setBar(Bar $bar) {
        $this->bar = $bar;
    }
}

Notez que vous pouvez réellement type de la déclaration, comme ?Bar depuis la version 7.1 (nullable), car il pourrait être null (non disponible dans php7.0.)

Vous pouvez également le type de retour void depuis php7.1

InformationsquelleAutor Bruno Guignard

Vous pouvez utiliser setter

class Bar {
    public $val;
}

class Foo {
    /**
     *
     * @var Bar
     */
    private $bar;

    /**
     * @return Bar
     */
    public function getBar()
    {
        return $this->bar;
    }

    /**
     * @param Bar $bar
     */
    public function setBar(Bar $bar)
    {
        $this->bar = $bar;
    }

}

$fooInstance = new Foo();
//$fooInstance->bar = new NotBar(); //Error
$fooInstance->setBar($fooInstance);

De sortie:

TypeError: Argument 1 passed to Foo::setBar() must be an instance of Bar, instance of Foo given, called in ...

InformationsquelleAutor Richard

Vous devez vous connecter pour publier un commentaire.