Para realmente entender o que estamos falando quando falamos sobre selfversus $this, precisamos realmente descobrir o que está acontecendo nos níveis conceitual e prático. Eu realmente não sinto que nenhuma das respostas faça isso adequadamente, então aqui está minha tentativa.
Vamos começar falando sobre o que classe e um objeto .
Classes e objetos, conceitualmente
Então, o que é uma aula ? Muitas pessoas o definem como um modelo ou modelo para um objeto. De fato, você pode ler mais sobre classes no PHP aqui . E até certo ponto é isso que realmente é. Vejamos uma classe:
class Person {
public $name = 'my name';
public function sayHello() {
echo "Hello";
}
}
Como você pode ver, existe uma propriedade nessa classe chamada $namee um método (função) chamado sayHello().
É muito importante observar que a classe é uma estrutura estática. O que significa que a classe Person, uma vez definida, é sempre a mesma em todos os lugares.
Um objeto, por outro lado, é chamado de instância de uma classe. O que isso significa é que pegamos o "blueprint" da classe e o usamos para fazer uma cópia dinâmica. Agora, esta cópia está vinculada especificamente à variável em que está armazenada. Portanto, qualquer alteração em uma instância é local para ela.
$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"
Criamos novas instâncias de uma classe usando o newoperador
Portanto, dizemos que uma classe é uma estrutura global e um objeto é uma estrutura local. Não se preocupe com essa ->sintaxe engraçada , vamos abordar isso daqui a pouco.
Outra coisa sobre a qual devemos falar é que podemos verificar se uma instância é uma instanceofclasse específica: $bob instanceof Personque retorna um booleano se a $bobinstância foi criada usando a Personclasse ou um filho de Person.
Estado definidor
Então, vamos nos aprofundar no que uma classe realmente contém. Existem 5 tipos de "coisas" que uma classe contém:
Propriedades - Pense nelas como variáveis que cada instância conterá.
class Foo {
public $bar = 1;
}
Propriedades estáticas - pense nelas como variáveis compartilhadas no nível da classe. Significando que eles nunca são copiados por cada instância.
class Foo {
public static $bar = 1;
}
Métodos - São funções que cada instância conterá (e operará em instâncias).
class Foo {
public function bar() {}
}
Métodos estáticos - são funções compartilhadas por toda a classe. Eles não operam em instâncias, mas apenas nas propriedades estáticas.
class Foo {
public static function bar() {}
}
Constantes - constantes resolvidas em classe. Não indo mais fundo aqui, mas adicionando a integridade:
class Foo {
const BAR = 1;
}
Então, basicamente, estamos armazenando informações no contêiner de classe e objeto usando "dicas" sobre estática que identificam se a informação é compartilhada (e, portanto, estática) ou não (e, portanto, dinâmica).
Estado e Métodos
Dentro de um método, a instância de um objeto é representada pela $thisvariável O estado atual desse objeto está lá e a mutação (alteração) de qualquer propriedade resultará em uma alteração nessa instância (mas não em outras).
Se um método é chamado estaticamente, a $thisvariável não está definida . Isso ocorre porque não há instância associada a uma chamada estática.
O interessante aqui é como as chamadas estáticas são feitas. Então, vamos falar sobre como acessamos o estado:
Estado de acesso
Então agora que armazenamos esse estado, precisamos acessá-lo. Isso pode ser um pouco complicado (ou muito mais que um pouco), então vamos dividir isso em dois pontos de vista: de fora de uma instância / classe (digamos, de uma chamada de função normal ou do escopo global) e dentro de uma instância / class (de dentro de um método no objeto).
De fora de uma instância / classe
Do lado de fora de uma instância / classe, nossas regras são bastante simples e previsíveis. Temos dois operadores e cada um nos diz imediatamente se estamos lidando com uma instância ou uma classe estática:
->- operador de objeto - sempre é usado quando estamos acessando uma instância.
$bob = new Person;
echo $bob->name;
É importante observar que a chamada Person->foonão faz sentido (já que Personé uma classe, não uma instância). Portanto, esse é um erro de análise.
::- scope-resolution-operator - Isso sempre é usado para acessar uma propriedade ou método estático de classe.
echo Foo::bar()
Além disso, podemos chamar um método estático em um objeto da mesma maneira:
echo $foo::bar()
É extremamente importante observar que, quando fazemos isso de fora , a instância do objeto fica oculta do bar()método. Significando que é exatamente o mesmo que em execução:
$class = get_class($foo);
$class::bar();
Portanto, $thisnão está definido na chamada estática.
De dentro de uma instância / classe
As coisas mudam um pouco aqui. Os mesmos operadores são usados, mas seu significado se torna significativamente desfocado.
O operador de objeto -> ainda é usado para fazer chamadas para o estado da instância do objeto.
class Foo {
public $a = 1;
public function bar() {
return $this->a;
}
}
Chamar o bar()método $foo(uma instância de Foo) usando o operador de objeto: $foo->bar()resultará na versão da instância de $a.
Então é assim que esperamos.
O significado do ::operador muda. Depende do contexto da chamada para a função atual:
Dentro de um contexto estático
Dentro de um contexto estático, todas as chamadas feitas usando ::também serão estáticas. Vejamos um exemplo:
class Foo {
public function bar() {
return Foo::baz();
}
public function baz() {
return isset($this);
}
}
A chamada Foo::bar()chamará o baz()método estaticamente e, portanto $this, não será preenchida. Vale a pena notar que nas versões recentes do PHP (5.3+) isso acionará um E_STRICTerro, porque estamos chamando métodos não estáticos estaticamente.
Dentro de um contexto de instância
Em um contexto de instância, por outro lado, as chamadas feitas usando ::dependem do receptor da chamada (o método que estamos chamando). Se o método for definido como static, ele usará uma chamada estática. Caso contrário, ele encaminhará as informações da instância.
Portanto, observando o código acima, a chamada $foo->bar()retornará true, pois a chamada "estática" acontece dentro de um contexto de instância.
Faz sentido? Não achava isso. É confuso.
Palavras-chave de atalho
Como amarrar tudo junto usando nomes de classe é bastante sujo, o PHP fornece três palavras-chave básicas de "atalho" para facilitar a resolução do escopo.
self- Refere-se ao nome da classe atual. O self::baz()mesmo acontece Foo::baz()com a Fooclasse (qualquer método nela).
parent - Refere-se ao pai da classe atual.
static- Refere-se à classe chamada. Graças à herança, as classes filho podem substituir métodos e propriedades estáticas. Portanto, chamá-los usando o staticnome de uma classe em vez de um nome de classe nos permite resolver de onde a chamada veio, em vez do nível atual.
Exemplos
A maneira mais fácil de entender isso é começar a examinar alguns exemplos. Vamos escolher uma aula:
class Person {
public static $number = 0;
public $id = 0;
public function __construct() {
self::$number++;
$this->id = self::$number;
}
public $name = "";
public function getName() {
return $this->name;
}
public function getId() {
return $this->id;
}
}
class Child extends Person {
public $age = 0;
public function __construct($age) {
$this->age = $age;
parent::__construct();
}
public function getName() {
return 'child: ' . parent::getName();
}
}
Agora, também estamos olhando para herança aqui. Ignore por um momento que este é um modelo de objeto ruim, mas vamos ver o que acontece quando brincamos com isso:
$bob = new Person;
$bob->name = "Bob";
$adam = new Person;
$adam->name = "Adam";
$billy = new Child;
$billy->name = "Billy";
var_dump($bob->getId()); // 1
var_dump($adam->getId()); // 2
var_dump($billy->getId()); // 3
Portanto, o contador de ID é compartilhado entre as instâncias e os filhos (porque estamos usando selfpara acessá-lo. Se o usássemos static, poderíamos substituí-lo em uma classe filho).
var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy
Observe que estamos sempre executando o método da Person::getName() instância . Mas estamos usando o parent::getName()para fazer isso em um dos casos (o caso filho). É isso que torna essa abordagem poderosa.
Palavra de cautela # 1
Observe que o contexto de chamada é o que determina se uma instância é usada. Portanto:
class Foo {
public function isFoo() {
return $this instanceof Foo;
}
}
Nem sempre é verdade.
class Bar {
public function doSomething() {
return Foo::isFoo();
}
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)
Agora é realmente estranho aqui. Estamos chamando uma classe diferente, mas a $thisque é passada para o Foo::isFoo()método é a instância de $bar.
Isso pode causar todos os tipos de erros e problemas conceituais com o WTF. Então eu sugiro evitar o ::operador de dentro métodos de instância em qualquer coisa, exceto esses três "atalho" palavras-chave virtuais ( static, self, e parent).
Palavra de cautela # 2
Observe que métodos e propriedades estáticas são compartilhados por todos. Isso os torna basicamente variáveis globais. Com todos os mesmos problemas que vêm com globais. Portanto, eu hesitaria muito em armazenar informações em métodos / propriedades estáticas, a menos que você se sinta à vontade em ser verdadeiramente global.
Palavra de cautela # 3
Em geral, convém usar o que é conhecido como ligação estática tardia usando em staticvez de self. Mas observe que eles não são a mesma coisa; portanto, dizer "sempre use em staticvez de selfé realmente míope. Em vez disso, pare e pense na chamada que deseja fazer e pense se deseja que as classes filho possam substituir a estática resolvida". ligar.
TL / DR
Que pena, volte e leia. Pode ser muito longo, mas é longo, porque esse é um tópico complexo
TL / DR # 2
Ok, tudo bem. Em resumo, selfé usado para referenciar o nome da classe atual dentro de uma classe, onde, como $thisse refere à instância do objeto atual . Observe que selfé um atalho de copiar / colar. Você pode substituí-lo com segurança pelo nome da sua classe e funcionará bem. Mas $thisé uma variável dinâmica que não pode ser determinada com antecedência (e pode até não ser sua classe).
TL / DR # 3
Se o operador de objeto for usado ( ->), você sempre saberá que está lidando com uma instância. Se o operador de resolução de escopo for usado ( ::), você precisará de mais informações sobre o contexto (já estamos em um contexto de objeto? Estamos fora de um objeto? Etc).