Jonathan Lamim (Convidado)
Jonathan Lamim (Convidado)

#6 PHP 7 – Mudanças relacionadas a Programação Orientada a Objetos

Compartilhe

O PHP 5 e seus sucessores trouxeram várias alterações sobre o mode do objetos, já o PHP 7 quase não trouxe novos recursos nesse sentido, mas, mesmo sendo poucos, os que vieram são bastante interessantes.

Context-Sensitive lexer

Permite o uso de palavras-chave como nome de propriedades, métodos e constantes dentro de classes, interfaces e traits.

Isso quer dizer que o PHP vai ter apenas uma palavra-chave reservada, ‘class’, e somente no contexto de constante da classe.

Veja abaixo a lista de palavras-chave que você poderá utilizar como propriedade, função e nomes de constantes:

callable, and, include, function, trait, global, include_once, if, extends, goto, throw, endswitch, implements, instanceof, array, finally, static, insteadof, print, for, abstract, interface, echo, foreach, final, namespace, require, declare, public, new, require_once, case, protected, or, return, do, private, or, else, while, const, try, elseif, as, enddeclare, use, default, catch, endfor, var, break, die, endforeach, exit, continue, self, endif, list, switch, parent, endwhile, clone, yield, class.

A única exceção é não poder usar ‘const class’, pois entra em conflito com o nome da constante mágica do PHP 5.5.

Construtores descontinuados do PHP 4

Ao invés de remover os construtores do PHP 4 – que estava sendo pedido por muitos na comunidade – eles foram marcados como “deprecated” (obsoletos) no PHP 7.

Remover esses construtores causaria um problema de compatibilidade com códigos escritos para aplicações em versões anteriores do PHP. Caso venham a ser removidos, isso acontecerá no PHP 8, o que não vai afetar as aplicações e desenvolvedores por um bom tempo.

A utilização dos construtores do PHP 4 foi anulada quando os namespaces das classes foram introduzidos no PHP 5.3.

Declarações de grupo

As declarações de grupo são o resultado de um esforço para reduzir a duplicação e simplificar o código escrito.

As declarações de grupo permitem remover a duplicação de prefixos comuns, especificando partes únicas dentro de um bloco ({}).

Veja nos códigos abaixo uma exemplo de como essas declarações de grupo podem ser utilizadas:

Usando ‘group use statements’

// Original
use Framework\Component\ClassA;
use Framework\Component\ClassB as ClassC;
use Framework\OtherComponent\ClassD;

// Com group use statements
use Framework\{
Component\ClassA,
Component\ClassB as ClassC,
OtherComponent\ClassD
};

 

Organização alternativa de ‘guse statements’

use Framework\Component\{
ClassA,
ClassB as ClassC
};
Use Framework\OtherComponent\ClassD;

 

Veja que em ambos os códigos as declarações repetidas foram sendo agrupadas, de forma a reduzir o conteúdo duplicado das declarações.

Se você quiser importar funções ou constantes – feature que foi adicionada no PHP 5.6 – você deve simplesmente adicionar o prefixo com a função ou constante. Veja a seguir um exemplo de código com uso desse recurso:

use Framework\Component\{
SubComponent\ClassA,
function OtherComponent\someFunction,
const OtherComponent\SOME_CONSTANT
};

 

Classe Anônima

Classes anônimas, proavelmente, são o mais perto que chegaremos de uma sintaxe literal de objetos no PHP.

Para criar uma classe anônima você simplesmente combina a nova classe, seguida de uma definição de classe padrão.

A classe anônima é sempre instanciada durante a criação, dando-lhe um objeto dessa classe.

$object = new class("bar") {
public $foo;

public function __construct($arg)
{
$this->foo = $arg;
}
};

 

O código acima cria um objeto com um método construtor '__construct()', chamado com o argumento 'bar' e com a propriedade '$foo', atribuindo o valor do argumento ao construtor.

object(class@anonymous)#1 (1) {
["foo"]=>
string(3) "bar"
}

 

Classes anônimas podem ser namespaced, oferecendo suporte a herança, traits, interfaces, usando a mesma sintaxe de classes regulares.

namespace MyProject\Component;

$object = new class ($args) extends Foo implements Bar {
use Bat;
};

 

Nomes de classes anônimas

Pode parecer estranho nomear uma classe anônima, afinal, ela é anônima. O nome de uma classe anônima é baseado no endereço de memória da operação que a criou, por exemplo: class@0x7fa77f271bd0

Imagina que estivesse criando classes anônimas dentro de um loop, a classe teria o mesmo endereço de memória de cada iteração desse loop, o que faria com que somente uma classe fosse definida.

Isso sognifica que se o objeto resultante de duas iterações têm o mesmo valor de propriedades, elas serão iguais (== mas não idênticas ===).

No entanto, mesmo se você definir outra classe anônima com a mesma estrutura, em outro lugar do código, ela terá um nome diferente com base em seu endereço de memória, e então não será igual.

Veja no código abaixo a ilustração do que foi falado acima.

$objects = [];
foreach (["foo", "foo", "bar"] as $value) {
$objects[] = new class($value) {

public $value;

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

$objects[] = new class("foo") {

public $value;

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

 

No código acima foram criadas 3 instâncias de uma classe anônima dentro do loop foreach. Os dois primeiros são passados como ‘foo’ ao construtor, e o terceiro é passado como ‘bar’. Fora do loop foi criada uma quarta classe anônima, com a mesma definição, e novamente foi passado ‘foo’ para o construtor.

Devido a isso, os 2 primeiros objetos – $objects[0] e $objects[1] respectivamente – são iguais mas não idênticos. No entanto, nenhum desses 2 objetos é igual ao terceiro – $objects[2] e também não serão iguais ao quarto – $objects[3] – já que esse foi definido fora do loop, e apesar de ter estrutura e valor idênticos, é uma classe diferente, com um nome diferente, pois está alocado em outro endereço de memória.

Conclusão

Enquanto o foco do PHP 7 não é de alterar muito o modelo de dados, as alterações adicionadas são substanciais, classes anônimas abre uma série de novas possiblidades de arquitetura.

Essas mudanças tornarão o código orientado a objeto mais robusto e fácil de ser escrito.

Confira outros posts da série PHP 7 da Umbler:

Jonathan Lamim (Convidado)
Jonathan Lamim (Convidado)