Atributos em PHP

Os atributos em PHP, também conhecidos como annotations (anotações), foram introduzidos na versão PHP 8 e trouxeram uma forma poderosa de adicionar metadados a classes, métodos, e propriedades.

Esses metadados fornecem informações adicionais que podem ser usadas pelo código ou por frameworks para aplicar regras, validações ou até mesmo alterar o comportamento do programa de maneira dinâmica. Neste post, vamos explorar o que são os atributos, como eles funcionam e quando utilizá-los.

O que são Atributos?

Um atributo em PHP é uma estrutura que permite associar dados adicionais a várias partes do código, como classes, métodos, funções, propriedades e parâmetros. Esses dados não afetam diretamente o funcionamento do código, mas podem ser usados por outros componentes ou frameworks para influenciar o comportamento de uma aplicação.

A sintaxe de atributos em PHP utiliza #[ ] para definir os atributos diretamente sobre o código onde eles devem ser aplicados.

Sintaxe de Atributos

A sintaxe básica de atributos em PHP é simples. Você pode declarar um ou mais atributos antes de qualquer declaração de classe, método ou propriedade. Aqui está um exemplo básico de como definir um atributo em PHP:

#[ExemploAtributo]
class MinhaClasse {
    #[ExemploAtributo]
    public function meuMetodo() {
        // código do método
    }
}

No exemplo acima, o atributo ExemploAtributo foi aplicado à classe MinhaClasse e ao método meuMetodo. Esse atributo pode ser utilizado por um código externo para realizar operações adicionais.

Como criar e usar Atributos

Os atributos em PHP são definidos como classes que utilizam a anotação #[Attribute]. Vamos ver como criar um atributo personalizado:

#[Attribute]
class ExemploAtributo {
    public string $mensagem;

    public function __construct(string $mensagem) {
        $this->mensagem = $mensagem;
    }
}

Aqui, estamos criando um atributo chamado ExemploAtributo com um construtor que recebe uma mensagem como parâmetro. Agora, podemos aplicar esse atributo em classes ou métodos:

#[ExemploAtributo('Esse é um exemplo de atributo')]
class MinhaClasse {
    #[ExemploAtributo('Atributo aplicado ao método')]
    public function meuMetodo() {
        // código do método
    }
}

Obtendo Atributos com Reflection

Uma das grandes vantagens dos atributos é que você pode acessar suas informações dinamicamente usando a classe Reflection. Isso permite que você inspecione os atributos e seus valores em tempo de execução. Veja um exemplo de como obter os atributos de uma classe ou método:

$refClasse = new ReflectionClass(MinhaClasse::class);
$atributos = $refClasse->getAttributes();

foreach ($atributos as $atributo) {
    $instanciaAtributo = $atributo->newInstance();
    echo $instanciaAtributo->mensagem; // Saída: Esse é um exemplo de atributo
}

No exemplo acima, estamos utilizando a classe ReflectionClass para obter os atributos aplicados à classe MinhaClasse e exibindo a mensagem armazenada no atributo.

Atributos com argumentos

Os atributos podem receber argumentos, o que permite maior flexibilidade e customização. Aqui está um exemplo onde passamos múltiplos parâmetros para um atributo:

#[Attribute]
class Rota {
    public string $url;
    public string $metodo;

    public function __construct(string $url, string $metodo = 'GET') {
        $this->url = $url;
        $this->metodo = $metodo;
    }
}

#[Rota('/usuarios', 'POST')]
class UsuarioController {
    #[Rota('/usuarios/criar', 'POST')]
    public function criarUsuario() {
        // lógica para criar um usuário
    }
}

Neste exemplo, o atributo Rota é utilizado para definir uma rota para a classe UsuarioController e o método criarUsuario. Ele aceita dois argumentos: a URL e o método HTTP (GET, POST, etc.).

Quando usar Atributos em PHP?

Os atributos são úteis em vários cenários, especialmente quando você deseja adicionar metadados para frameworks ou bibliotecas que precisam processar o código de maneira dinâmica. Aqui estão alguns exemplos de onde os atributos podem ser usados:

• Validações: Adicionar regras de validação a propriedades de uma classe de maneira mais declarativa;
  
  
• Rotas: Definir rotas em um framework de controle MVC;
  
  
• Controle de autenticação: Definir quais métodos ou classes exigem autenticação ou permissões específicas;
  
  
• Mapeamento de banco de dados: Utilizar atributos para mapear classes a tabelas de banco de dados (ORM).

Exemplo de validação com Atributos

Um caso comum é utilizar atributos para validação de dados. Veja o exemplo abaixo:

#[Attribute]
class ValidaEmail {
    public function __construct() {}

    public function validar(string $email): bool {
        return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
    }
}

class Usuario {
    #[ValidaEmail]
    public string $email;

    public function __construct(string $email) {
        $this->email = $email;
    }
}

$usuario = new Usuario('exemplo@dominio.com');
$refPropriedade = new ReflectionProperty(Usuario::class, 'email');
$atributos = $refPropriedade->getAttributes();

foreach ($atributos as $atributo) {
    $validador = $atributo->newInstance();
    if (!$validador->validar($usuario->email)) {
        echo "Email inválido!";
    } else {
        echo "Email válido!";
    }
}

Neste exemplo, criamos um atributo ValidaEmail que valida se o email de um usuário é válido ou não.

Outro exemplo:

 class Veiculo {
 
  //Atributos da classe
  private $modelo;
  private $motor;
  private $ano;
 
 //Método get para acessar o atributo privado $modelo	 
 public function getModelo() {
   return $this->modelo; //$this define que o valor retornado será o valo do atributo $modelo
 }
 	
  //Método set para alterar o valor do atributo privado $modelo  
  public function setModelo($modelo) {
   $this->modelo = $modelo;
 }	 
  public function getMotor() {
   return $this->motor;
  }	 
  public function setMotor($motor) {
   $this->motor= $motor;
  }
  public function getAno():int {
   return $this->ano;
  }	 
  public function setAno($ano) {
   $this->ano = $ano;
  }
  
  //Método para atribuir e mostrar valores dos atributos privados	 
  public function exibirVeiculos() {
   return array( //Define um array para armazenar os valores dos atributos modelo, motor e ano
    "modelo"=>$this->getModelo(), //Define os valores para os atributos através dos métodos get
    "motor"=>$this->getMotor(),
    "ano"=>$this->getAno()
   );
  }  
 }
 
 //Cria o objeto $celta (instancia a classe Veiculo)
 $celta = new Veiculo();
 
 //Atribui valor ao atributo $modelo através do objeto $celta usando o método setModelo()
 $celta->setModelo("Spirit"); 
 
 $celta->setMotor("1.0");
 $celta->setAno("2011");
 
 //Acessa e mostra os valores armazenados no array
 var_dump($celta->exibirVeiculos()); //var_dump() mostra o tipo de atributo retornado
 } 

É importante a utilização dos métodos get e set para controlar o que pode ou não ser lido e atribuído aos atributos através de validações dentro dos próprios métodos.

Os atributos em PHP são uma poderosa adição ao arsenal de ferramentas da linguagem, permitindo que desenvolvedores adicionem metadados a classes, métodos e propriedades de forma flexível e intuitiva. Essa funcionalidade é especialmente útil em frameworks e bibliotecas que exigem a capacidade de definir regras e comportamentos adicionais no código sem afetar sua estrutura principal.

Com os atributos, o PHP se aproxima de outras linguagens modernas que utilizam anotações para enriquecer o código, facilitando a implementação de validações, mapeamentos e outras funcionalidades. Ao compreender como os atributos funcionam, você pode construir sistemas mais eficientes e flexíveis em suas aplicações PHP.

Dúvidas ou sugestões sobre atributos em PHP? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: atributos