Traits avec PHP et Laravel

Traits sont parfois décrits comme des "compilateur assistée de " copier-coller"; le résultat de l'utilisation d'un Trait peut toujours être écrite comme valide de classe dans son propre droit. Il n'y a donc pas de notion de parent dans un Trait, car une fois que le Trait a été appliqué, ses méthodes sont identiques à celles définies dans la classe elle-même, ou importées à partir d'autres Traits en même temps.

De même, comme le PHP docs dire:

Si deux Traits insérer une méthode avec le même nom, une erreur irrécupérable s'est produite, si le conflit n'est pas explicitement résolu.

En tant que tels, ils ne sont pas très approprié pour les situations où vous voulez mélanger dans de multiples variantes de la même pièce de comportement, car il n'existe aucun moyen pour les fonctionnalités de base et mixtes dans la fonctionnalité de parler les uns aux autres de manière générique.

Dans ma compréhension du problème que vous êtes en train d'essayer de résoudre est: est-ce

• ajouter des Accesseurs et des Mutateurs à une Éloquente de la classe du modèle
• ajouter d'autres éléments à l'protégé $appends tableau correspondant à ces méthodes

Une approche pourrait être de continuer à utiliser les Traits, et l'utilisation La réflexion de découvrir de manière dynamique les méthodes qui ont été ajoutés. Cependant, méfiez-vous de cette Réflexion a la réputation d'être plutôt lent.

Pour ce faire, nous avons d'abord mettre en œuvre un constructeur avec une boucle sur laquelle on peut raccorder simplement en nommant une méthode d'une manière particulière. Ce peut être placé dans un Trait de caractère qui lui est propre (sinon, vous pouvez sous-classe de la Éloquent Model classe avec votre propre version améliorée):

trait AppendingGlue {
  public function __construct() {
    //parent refers not to the class being mixed into, but its parent
    parent::__construct();

    //Find and execute all methods beginning 'extraConstruct'
    $mirror = new ReflectionClass($this);
    foreach ( $mirror->getMethods() as $method ) {
      if ( strpos($method->getName(), 'extraConstruct') === 0 ) {
        $method->invoke($this);
      }
    }
  }
}

Ensuite n'importe quel nombre de Traits de la mise en œuvre de nom différent extraConstruct méthodes:

trait AwesomeSauce {
  public function extraConstructAwesomeSauce() {
    $this->appends[] = 'awesome_sauce';
  }

  public function doAwesomeSauceStuff() {
  }
}

trait ChocolateSprinkles {
  public function extraConstructChocolateSprinkles() {
    $this->appends[] = 'chocolate_sprinkles';
  }

  public function doChocolateSprinklesStuff() {
  }
}

Enfin, on mélange dans tous les traits dans une plaine modèle, et regardez le résultat:

class BaseModel {
  protected $appends = array('base');

  public function __construct() {
    echo "Base constructor run OK.\n";
  }

  public function getAppends() {
    return $this->appends;
  }
}

class DecoratedModel extends BaseModel {
  use AppendingGlue, AwesomeSauce, ChocolateSprinkles;
}

$dm = new DecoratedModel;
print_r($dm->getAppends());

Nous pouvons définir le contenu initial de $appends à l'intérieur de la décorées modèle lui-même, et il remplacera le BaseModel définition, mais de ne pas interrompre les autres Traits:

class ReDecoratedModel extends BaseModel {
  use AppendingGlue, AwesomeSauce, ChocolateSprinkles;

  protected $appends = ['switched_base'];
}

Toutefois, si vous supprimez le constructeur en même temps que le mélange dans la AppendingGluevous avez besoin de faire un peu de travail supplémentaire, comme discuté dans cette précédente réponse. Il est similaire à l'appel parent::__construct dans un héritage de la situation, mais vous devez alias le trait du constructeur pour y accéder:

class ReConstructedModel extends BaseModel {
  use AppendingGlue { __construct as private appendingGlueConstructor; }
  use AwesomeSauce, ChocolateSprinkles;

  public function __construct() {
    //Call the mixed-in constructor explicitly, like you would the parent
    //Note that it will call the real parent as well, as though it was a grand-parent
    $this->appendingGlueConstructor();

    echo "New constructor executed!\n";
  }
}

Cela peut être évité en héritant d'une classe qui existe au lieu de la AppendingGlue trait de caractère, ou utilise d'ores et déjà:

class GluedModel extends BaseModel {
  use AppendingGlue;
}
class ReConstructedGluedModel extends GluedModel {
  use AwesomeSauce, ChocolateSprinkles;

  public function __construct() {
    //Standard call to the parent constructor
    parent::__construct();
    echo "New constructor executed!\n";
  }
}

Voici un démo en live de toutes qui rassemble.