Comment faire une variable privée à un trait de caractère?

J'aimerais réutiliser une fonctionnalité en plusieurs fois dans une même classe. Cette fonctionnalité s'appuie sur une variable privée:

trait Address {
    private $address;

    public function getAddress() {
        return $this->address;
    }

    public function setAddress($address) {
        $this->address = $address;
    }
}

Le seul moyen que j'ai trouvé pour utiliser le trait deux fois, est la suivante:

class User  {
    use Address {
        getAddress as getHomeAddress;
        setAddress as setHomeAddress;

        getAddress as getWorkAddress;            
        setAddress as setWorkAddress;
    }
}

Le problème est que, ce faisant, la variable privée $address est partagée entre les différentes méthodes, et le code ne fonctionnera pas comme prévu:

$user = new User();
$user->setHomeAddress('21 Jump Street');
echo $user->getWorkAddress(); //21 Jump Street

Est-il une solution pour vraiment utiliser le trait deux fois, tout en ne partageant pas ses variables privées?

OriginalL'auteur Benjamin | 2012-11-27

18

Déclarant un trait avec use ne va pas créer une instance de ce trait de caractère. Les Traits sont fondamentalement juste le code qui est de copier et collé à l'aide de la classe. Le as ne fera que créer un Alias pour cette méthode, par exemple, il va ajouter quelque chose comme
```
public function getHomeAddress()
{
    return $this->getAddress();
}
```
à votre classe d'Utilisateur. Mais il sera toujours seulement être qu'un trait de caractère. Il n'y aura pas deux $address propriétés, mais un seul.

Vous pourrait rendre les méthodes privé et ensuite déléguer tout appel public à la via __call par commutateur/boîtier sur le nom de la méthode et de l'utilisation d'un tableau pour l'adresse, par exemple
```
trait Address {
    private $address = array();

    private function getAddress($type) {
        return $this->address[$type];
    }

    private function setAddress($type, $address) {
        $this->address[$type] = $address;
    }

    public function __call($method, $args) {
        switch ($method) {
            case 'setHomeAddress':
                return $this->setAddress('home', $args[0]);
            //more cases …
        }
    }
}
```
Mais c'est juste une boîte de pandore.

En d'autres termes, vous ne pouvez pas sainement, faire ce que vous essayez de faire avec les traits. Soit utiliser deux traits différents. Ou utiliser la bonne vieille agrégation et d'ajouter en béton méthodes d'approximation.

Même si je comprends que les traits ne sont pas instanciée, j'étais encore enceinte de leur variables privées de ne pas être visible de la classe à l'aide d'entre eux, ce qui peut permettre de les utiliser plusieurs fois dans une même classe, avec des alias de noms de méthode. Regarde comme je me suis trompé, donc merci pour votre réponse!
chaque classe à l'aide de ce trait de caractère, aura sa propre instance de la $address variable, mais il sera bien évidemment être visible de la classe à l'aide, parce que les traits de simplement ajouter un peu de comportement des classes.
Oui, cela devient un peu plus clair dans ma tête... Ce qui est différent de l'héritage multiple, car avec l'héritage de la variable serait visible que dans la super-classe, où ici, la variable privée du trait est tout simplement "copié" à la classe réelle.
Cette solution semble assez terrible. Les Traits ne sont pas destinés à remplacer les objets - Juste obtenir une adresse d'objet (POPO) si vous avez besoin d'un ...
c'est pourquoi la réponse dit que c'est une boîte de pandore.

OriginalL'auteur

j'ai peut-être un peu en retard pour la fête, mais le comportement que vous essayez de créer n'est pas quelque chose qui doit être couverte par un trait, mais par simple composition d'objet.

<?php
class Adddress {
    private $street;
    private $number;
    public function __construct(string $street, ?string $number) {}
    public function street() : string {}
    public function number() : string {}
}
class User {
    private $homeAddress;
    private $workAddress;
    public function getHomeAddress() : Address {}
    public function setHomeAddress(Address $homeAddress) : self {}
    public function getWorkAddress() : Address {}
    public function setWorkAddress(Address $workAddress) : self {}
}

Cela va à l'encontre du but d'avoir un trait de caractère.
Les Traits de la défaite. C'est juste un POO de l'écriture PHP3 code de style.

OriginalL'auteur

0

J'ai confirmé que vous pouvez alias la même fonction à plusieurs reprises, ce qui était une surprise pour moi. Bien que ZendStudio semble que 'assistance de code" sur le dernier alias de la fonction.

Être en mesure d'attribuer la même fonction à plusieurs reprises pourrait se prêter à certains comportement intéressant si le Trait fonction peut déterminer quel nom il a été appelé. Mais il ne semble pas que nous pouvons déterminé la 'alias' la fonction à l'intérieur d'un trait de fonction.

Voici mon code de test:
```
<?php
trait TestTrait
{
    public function test() { print __CLASS__ . ', ' . __TRAIT__ . ', ' . __METHOD__ . ', ' . __FUNCTION__  . "\n"; }
}
class TestClass
{
    use TestTrait { test as test1; test as test2; }
}
$c = new TestClass();
$c->test1();
$c->test2();
```
De sortie:
```
TestClass, TestTrait, TestTrait::test, test
TestClass, TestTrait, TestTrait::test, test
```
Il serait peut-être bien d'ajouter une nouvelle ALIAS constante pour trait fonctions de déterminer ce que l'alias qu'ils ont été appelés.

En fait, j'ai créé PHP demande de fonctionnalité pour cette:

https://bugs.php.net/bug.php?id=63629

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.