PHP Academy · Aula

Traits para reutilização de código

Insira blocos de código reutilizáveis em classes com trait.

Traits para reutilização de código é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

Introdução: Traços do PHP

Um traço é uma unidade de código reutilizável que pode ser incorporada a qualquer classe. Ele resolve o problema da reutilização horizontal de código em linguagens com herança única. Use traços quando várias classes sem relação precisarem do mesmo comportamento.

Conceitos principais

Conceitos principais:

Declare com trait Name {}
Inclua com use TraitName; dentro de uma classe
Os traços podem ter propriedades e métodos
Resolva conflitos com insteadof e as

Traço básico

Exemplo:

<?php
trait Timestamps {
    private ?string $createdAt = null;
    private ?string $updatedAt = null;

    public function setCreatedAt(): void { $this->createdAt = date('c'); }
    public function setUpdatedAt(): void { $this->updatedAt = date('c'); }
    public function getCreatedAt(): ?string { return $this->createdAt; }
}

class Post {
    use Timestamps;
    public function __construct(public string $title) {
        $this->setCreatedAt();
    }
}

$p = new Post('Hello');
echo $p->getCreatedAt();

Vários traços

Continuação:

<?php
trait SoftDelete {
    private ?string $deletedAt = null;
    public function delete(): void { $this->deletedAt = date('c'); }
    public function isDeleted(): bool { return $this->deletedAt !== null; }
    public function restore(): void { $this->deletedAt = null; }
}

trait HasSlug {
    private string $slug = '';
    public function setSlug(string $title): void {
        $this->slug = strtolower(preg_replace('/[^a-z0-9]+/i', '-', $title));
    }
}

class Article {
    use Timestamps, SoftDelete, HasSlug;
}

Resolução de conflitos entre traços

Mais detalhes:

<?php
trait A {
    public function hello(): string { return 'Hello from A'; }
}

trait B {
    public function hello(): string { return 'Hello from B'; }
}

class C {
    use A, B {
        A::hello insteadof B;   // prefer A::hello
        B::hello as helloB;     // alias B::hello
    }
}

$c = new C();
echo $c->hello();   // Hello from A
echo $c->helloB();  // Hello from B

Traço com método abstrato

Uso prático:

<?php
trait Validatable {
    abstract protected function rules(): array;

    public function validate(array $data): array {
        $errors = [];
        foreach ($this->rules() as $field => $rule) {
            if ($rule === 'required' && empty($data[$field])) {
                $errors[$field] = "$field is required";
            }
        }
        return $errors;
    }
}

class RegistrationForm {
    use Validatable;
    protected function rules(): array {
        return ['email' => 'required', 'password' => 'required'];
    }
}

Traço versus interface versus classe abstrata

Avançado:

<?php
// Interface: contract (what a class CAN do)
// Abstract Class: partial template (what a class IS)
// Trait: code mixin (horizontal reuse — what a class DOES)

// Typical pattern: use all three together:
interface Cacheable {
    public function getCacheKey(): string;
}

trait CacheableTrait {
    public function cache(CacheInterface $cache): void {
        $cache->set($this->getCacheKey(), $this);
    }
}

Padrão

Padrões comuns de traços do PHP são usados para resolver de forma organizada problemas recorrentes de design. Aplique-os de maneira consistente para obter um código legível e fácil de manter.

Quando usar

Saber quando aplicar traços do PHP é tão importante quanto saber como. O uso excessivo leva à complexidade; o uso insuficiente leva à duplicação.

Exemplo do mundo real

Em aplicações reais, os traços do PHP aparecem com frequência em estruturas, ORMs e camadas de serviço. Compreendê-los prepara você para contribuir com projetos profissionais em PHP.

Armadilhas comuns

Evite estes erros ao trabalhar com traits do PHP:

Os traits resolvem o problema do diamante em linguagens com herança única
Use insteadof e as para resolver conflitos entre métodos de traits
Traits com métodos abstratos obrigam a classe que os utiliza a implementá-los
Prefira a composição (traits/interfaces) a hierarquias profundas de herança

Verificação rápida

Qual construção do PHP resolve a reutilização horizontal de código quando o mesmo comportamento é necessário em várias classes não relacionadas?

Recapitulação: traits do PHP

Resumo:

Os traits resolvem o problema do diamante em linguagens com herança única
Use insteadof e as para resolver conflitos entre métodos de traits
Traits com métodos abstratos obrigam a classe que os utiliza a implementá-los
Prefira a composição (traits/interfaces) a hierarquias profundas de herança

Perguntas Frequentes

A aula “Traits para reutilização de código” é grátis?

Sim — o texto completo de “Traits para reutilização de código” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Traits para reutilização de código”?

Insira blocos de código reutilizáveis em classes com trait. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Traits para reutilização de código”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy