Estou convertendo uma biblioteca PHP 5.3 para trabalhar no PHP 5.2. A principal coisa que está no meu caminho é o uso de ligação estática tardia como return new static($options);, se eu converter isso em para return new self($options)obter os mesmos resultados?
Qual é a diferença entre new selfe new static?
Respostas:
vou obter os mesmos resultados?
Na verdade não. Eu não sei de uma solução alternativa para o PHP 5.2, no entanto.
Qual é a diferença entre
new selfenew static?
selfrefere-se à mesma classe em que a newpalavra-chave é realmente escrita.
static, nas ligações estáticas tardias do PHP 5.3, refere-se a qualquer classe na hierarquia em que você chamou o método.
No exemplo a seguir, Bherda os dois métodos de A. A selfinvocação está vinculada a, Aporque é definida na Aimplementação do primeiro método, enquanto staticestá vinculada à classe chamada (também consulte get_called_class()).
class A {
public static function get_self() {
return new self();
}
public static function get_static() {
return new static();
}
}
class B extends A {}
echo get_class(B::get_self()); // A
echo get_class(B::get_static()); // B
echo get_class(A::get_self()); // A
echo get_class(A::get_static()); // Aget_called_class(), o que é efetivamente o mesmo que __CLASS__, mas compatível com LSB.
selfretornaria a si próprio e staticretornaria algo que não pode ser substituído ... Mas eis que é o contrário. Eu nunca deixo de me impressionar com a nomeação, convenções e estilo geral do PHP. #
Se o método desse código não for estático, você pode obter uma solução alternativa na 5.2 usando get_class($this).
class A {
public function create1() {
$class = get_class($this);
return new $class();
}
public function create2() {
return new static();
}
}
class B extends A {
}
$b = new B();
var_dump(get_class($b->create1()), get_class($b->create2()));Os resultados:
string(1) "B"
string(1) "B"clone, mas apenas recriando e configurando as propriedades. $copy = new static(); $copy->set($this->get()); return $copy;
self::ou static::afetará se a versão da classe base ou subclasse desse método estático é usada. Na ausência de algum motivo para pensar que tal situação ocorra indica inerentemente má prática (e não vejo nenhuma razão para que isso aconteça), a escolha entre self::e static::é tão relevante dentro de métodos não estáticos quanto em métodos estáticos. Eu entendi mal o seu comentário, ou alguém está simplesmente errado?
Além das respostas dos outros:
static :: será calculado usando informações de tempo de execução.
Isso significa que você não pode usar static::em uma propriedade de classe porque os valores das propriedades:
Deve poder ser avaliado em tempo de compilação e não deve depender das informações em tempo de execução.
class Foo {
public $name = static::class;
}
$Foo = new Foo;
echo $Foo->name; // Fatal errorUsando self::
class Foo {
public $name = self::class;
}
$Foo = new Foo;
echo $Foo->name; // FooObserve que o comentário do erro Fatal no código que eu fiz não indica onde o erro ocorreu, o erro aconteceu antes de o objeto ser instanciado como @Grapestain mencionado nos comentários
public $name = static::class;, não na linha 7, conforme sugerido pelo exemplo. O erro diz: "static :: class não pode ser usado para resolução de nomes de classes em tempo de compilação", o que indica que o problema não é onde você tenta acessar o campo $ name, mas muito antes, na compilação da classe PHP. A linha 7 (ou 6) não será alcançada no primeiro exemplo.