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: