Traços em PHP - existem exemplos / práticas recomendadas do mundo real? [fechadas]

Características foram uma das maiores adições para o PHP 5.4. Conheço a sintaxe e entendo a ideia por trás de características, como a reutilização de código horizontal para coisas comuns, como log, segurança, cache etc.

No entanto, ainda não sei como utilizaria as características de meus projetos.

Existem projetos de código aberto que já usam características? Algum bom artigo / material de leitura sobre como estruturar arquiteturas usando características?

Minha opinião pessoal é que, na verdade, existe muito pouca aplicação de características ao escrever código limpo.

Em vez de usar características para hackear código em uma classe, é melhor passar as dependências pelo construtor ou pelos setters:

class ClassName {
    protected $logger;

    public function __construct(LoggerInterface $logger) {
        $this->logger = $logger;
    }
    // or
    public function setLogger(LoggerInterface $logger) {
        $this->logger = $logger;
    }
}

A principal razão pela qual acho que melhor do que usar características é que seu código é muito mais flexível removendo o acoplamento rígido a uma característica. Por exemplo, você pode simplesmente passar uma classe de logger diferente agora. Isso torna seu código reutilizável e testável.

Acho que seria preciso procurar em idiomas que possuam Traits há algum tempo para aprender as Boas / Melhores práticas aceitas. Minha opinião atual sobre o Trait é que você deve usá-los apenas para códigos que precisaria duplicar em outras classes que compartilham a mesma funcionalidade.

Exemplo para uma característica do criador de logs:

interface Logger
{
    public function log($message, $level);    
}

class DemoLogger implements Logger
{
    public function log($message, $level)
    {
        echo "Logged message: $message with level $level", PHP_EOL; 
    }
}

trait Loggable // implements Logger
{
    protected $logger;
    public function setLogger(Logger $logger)
    {
        $this->logger = $logger;
    }
    public function log($message, $level)
    {
        $this->logger->log($message, $level);
    }
}

class Foo implements Logger
{
    use Loggable;
}

E então você faz ( demo )

$foo = new Foo;
$foo->setLogger(new DemoLogger);
$foo->log('It works', 1);

Eu acho que o importante a considerar ao usar traços é que eles realmente são apenas pedaços de código que são copiados para a classe. Isso pode facilmente levar a conflitos, por exemplo, quando você tenta alterar a visibilidade dos métodos, por exemplo,

trait T {
    protected function foo() {}
}
class A { 
    public function foo() {}
}
class B extends A
{
    use T;
}

O exemplo acima resultará em um erro ( demo ). Da mesma forma, quaisquer métodos declarados na característica que também já estão declarados na classe using não serão copiados para a classe, por exemplo

trait T {
    public function foo() {
    return 1;
}
}
class A { 
    use T;
    public function foo() {
    return 2;
}
}

$a = new A;
echo $a->foo();

imprimirá 2 ( demo ). Essas são as coisas que você deseja evitar, pois dificultam a localização dos erros. Você também deve evitar colocar coisas em características que operam nas propriedades ou métodos da classe que a utiliza, por exemplo,

class A
{
    use T;
    protected $prop = 1;
    protected function getProp() {
        return $this->prop;
    }
}

trait T
{
    public function foo()
    {
        return $this->getProp();
    }
}

$a = new A;
echo $a->foo();

funciona ( demo ), mas agora a característica está intimamente ligada a A e toda a idéia de reutilização horizontal é perdida.

Ao seguir o Princípio de Segregação de Interface, você terá muitas classes e interfaces pequenas. Isso faz da Traits um candidato ideal para as coisas que você mencionou, por exemplo , preocupações transversais , mas não para compor objetos (em um sentido estrutural). No exemplo do Logger acima, a característica é completamente isolada. Não possui dependências de classes concretas.

Poderíamos usar agregação / composição (como mostrado em outro lugar nesta página) para obter a mesma classe resultante, mas a desvantagem de usar agregação / composição é que teremos que adicionar os métodos proxy / delegador manualmente a cada classe, o que deve ser poder fazer logon. As características resolvem isso muito bem, permitindo-me manter o padrão em um só lugar e aplicá-lo seletivamente quando necessário.

Nota: dado que os traços são um novo conceito em PHP, todas as opiniões expressas acima estão sujeitas a alterações. Ainda não tive muito tempo para avaliar o conceito. Mas espero que seja bom o suficiente para lhe dar algo em que pensar.

:) Não gosto de teorizar e debater sobre o que deve ser feito com alguma coisa. Nesse caso, traços. Mostrarei a você o que acho útil para as características e você pode aprender com ela ou ignorá-la.

Traços - eles são ótimos para aplicar estratégias . Em resumo, os padrões de design da estratégia são úteis quando você deseja que os mesmos dados sejam manipulados (filtrados, classificados etc.) de maneira diferente.

Por exemplo, você tem uma lista de produtos que deseja filtrar com base em alguns critérios (marcas, especificações, qualquer que seja) ou classificados por diferentes meios (preço, etiqueta, qualquer que seja). Você pode criar uma característica de classificação que contenha funções diferentes para diferentes tipos de classificação (numérico, sequência, data etc.). Em seguida, você pode usar essa característica não apenas na sua classe de produto (conforme fornecido no exemplo), mas também em outras classes que precisam de estratégias semelhantes (para aplicar uma classificação numérica a alguns dados, etc.).

Tente:

<?php
trait SortStrategy {
    private $sort_field = null;
    private function string_asc($item1, $item2) {
        return strnatcmp($item1[$this->sort_field], $item2[$this->sort_field]);
    }
    private function string_desc($item1, $item2) {
        return strnatcmp($item2[$this->sort_field], $item1[$this->sort_field]);
    }
    private function num_asc($item1, $item2) {
        if ($item1[$this->sort_field] == $item2[$this->sort_field]) return 0;
        return ($item1[$this->sort_field] < $item2[$this->sort_field] ? -1 : 1 );
    }
    private function num_desc($item1, $item2) {
        if ($item1[$this->sort_field] == $item2[$this->sort_field]) return 0;
        return ($item1[$this->sort_field] > $item2[$this->sort_field] ? -1 : 1 );
    }
    private function date_asc($item1, $item2) {
        $date1 = intval(str_replace('-', '', $item1[$this->sort_field]));
        $date2 = intval(str_replace('-', '', $item2[$this->sort_field]));
        if ($date1 == $date2) return 0;
        return ($date1 < $date2 ? -1 : 1 );
    }
    private function date_desc($item1, $item2) {
        $date1 = intval(str_replace('-', '', $item1[$this->sort_field]));
        $date2 = intval(str_replace('-', '', $item2[$this->sort_field]));
        if ($date1 == $date2) return 0;
        return ($date1 > $date2 ? -1 : 1 );
    }
}

class Product {
    public $data = array();

    use SortStrategy;

    public function get() {
        // do something to get the data, for this ex. I just included an array
        $this->data = array(
            101222 => array('label' => 'Awesome product', 'price' => 10.50, 'date_added' => '2012-02-01'),
            101232 => array('label' => 'Not so awesome product', 'price' => 5.20, 'date_added' => '2012-03-20'),
            101241 => array('label' => 'Pretty neat product', 'price' => 9.65, 'date_added' => '2012-04-15'),
            101256 => array('label' => 'Freakishly cool product', 'price' => 12.55, 'date_added' => '2012-01-11'),
            101219 => array('label' => 'Meh product', 'price' => 3.69, 'date_added' => '2012-06-11'),
        );
    }

    public function sort_by($by = 'price', $type = 'asc') {
        if (!preg_match('/^(asc|desc)$/', $type)) $type = 'asc';
        switch ($by) {
            case 'name':
                $this->sort_field = 'label';
                uasort($this->data, array('Product', 'string_'.$type));
            break;
            case 'date':
                $this->sort_field = 'date_added';
                uasort($this->data, array('Product', 'date_'.$type));
            break;
            default:
                $this->sort_field = 'price';
                uasort($this->data, array('Product', 'num_'.$type));
        }
    }
}

$product = new Product();
$product->get();
$product->sort_by('name');
echo '<pre>'.print_r($product->data, true).'</pre>';
?>

Como observação final, penso em características como acessórios (que posso usar para alterar meus dados). Métodos e propriedades semelhantes que podem ser cortados das minhas aulas e colocados em um único local, para manutenção fácil, código mais curto e limpo.

Estou empolgado com o Traits, porque eles resolvem um problema comum ao desenvolver extensões para a plataforma de comércio eletrônico Magento. O problema ocorre quando as extensões adicionam funcionalidade a uma classe principal (como o modelo do usuário) estendendo-a. Isso é feito apontando o carregador automático do Zend (por meio de um arquivo de configuração XML) para usar o modelo de usuário da extensão e fazer com que esse novo modelo estenda o modelo principal. ( exemplo ) Mas e se duas extensões substituírem o mesmo modelo? Você obtém uma "condição de corrida" e apenas uma é carregada.

A solução agora é editar as extensões para que uma amplie a classe de substituição de modelo da outra em uma cadeia e, em seguida, defina a configuração da extensão para carregá-las na ordem correta para que a cadeia de herança funcione.

Esse sistema freqüentemente causa erros e, ao instalar novas extensões, é necessário verificar se há conflitos e editar extensões. Isso é doloroso e interrompe o processo de atualização.

Eu acho que usar Traits seria uma boa maneira de realizar a mesma coisa sem esse modelo irritante substituir a "condição de corrida". É verdade que ainda pode haver conflitos se várias características implementarem métodos com os mesmos nomes, mas eu imagino que algo como uma simples convenção de namespace possa resolver isso na maior parte do tempo.

TL; DR Acho que o Traits pode ser útil para criar extensões / módulos / plugins para grandes pacotes de software PHP como o Magento.

Você poderia ter uma característica para um objeto somente leitura como este:

  trait ReadOnly{  
      protected $readonly = false;

      public function setReadonly($value){ $this->readonly = (bool)$value; }
      public function getReadonly($value){ return $this->readonly; }
  }

Você pode detectar se essa característica é usada e determinar se deve ou não gravar esse objeto em um banco de dados, arquivo etc.