Para comprender realmente de qué estamos hablando cuando hablamos de selfversus $this, necesitamos profundizar en lo que sucede a nivel conceptual y práctico. Realmente no siento que ninguna de las respuestas haga esto apropiadamente, así que aquí está mi intento.
Comencemos hablando de qué es una clase y un objeto .
Clases y objetos, conceptualmente
Entonces, ¿qué es una clase ? Mucha gente lo define como un plano o una plantilla para un objeto. De hecho, puede leer más sobre las clases en PHP aquí . Y hasta cierto punto, eso es lo que realmente es. Veamos una clase:
class Person {
public $name = 'my name';
public function sayHello() {
echo "Hello";
}
}
Como puede ver, hay una propiedad en esa clase llamada $namey un método (función) llamado sayHello().
Es muy importante tener en cuenta que la clase es una estructura estática. Lo que significa que la clase Person, una vez definida, siempre es la misma en todas partes donde la miras.
Un objeto por otro lado es lo que se llama una instancia de una Clase. Lo que eso significa es que tomamos el "plano" de la clase y lo usamos para hacer una copia dinámica. Esta copia ahora está vinculada específicamente a la variable en la que está almacenada. Por lo tanto, cualquier cambio en una instancia es local para esa instancia.
$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"
Creamos nuevas instancias de una clase usando el newoperador.
Por lo tanto, decimos que una Clase es una estructura global, y un Objeto es una estructura local. No se preocupe por esa ->sintaxis divertida , vamos a entrar en eso en un momento.
Otra cosa de la que deberíamos hablar es que podemos verificar si una instancia es una instanceofclase particular: lo $bob instanceof Personque devuelve un valor booleano si la $bobinstancia se realizó utilizando la Personclase o un hijo de Person.
Estado definitorio
Así que profundicemos un poco en lo que realmente contiene una clase. Hay 5 tipos de "cosas" que contiene una clase:
Propiedades : piense en ellas como variables que contendrá cada instancia.
class Foo {
public $bar = 1;
}
Propiedades estáticas : piense en estas como variables que se comparten a nivel de clase. Lo que significa que nunca se copian por cada instancia.
class Foo {
public static $bar = 1;
}
Métodos : son funciones que cada instancia contendrá (y operará en instancias).
class Foo {
public function bar() {}
}
Métodos estáticos : son funciones que se comparten en toda la clase. Ellos no operan en los casos, pero en cambio en las propiedades estáticas solamente.
class Foo {
public static function bar() {}
}
Constantes : constantes resueltas por clase. No profundizando aquí, pero agregando para completar:
class Foo {
const BAR = 1;
}
Básicamente, estamos almacenando información sobre la clase y el contenedor de objetos usando "pistas" sobre estática que identifican si la información es compartida (y por lo tanto estática) o no (y por lo tanto dinámica).
Estado y métodos
Dentro de un método, la instancia representa la instancia de un objeto $this. El estado actual de ese objeto está allí, y la mutación (cambio) de cualquier propiedad dará como resultado un cambio en esa instancia (pero no en otras).
Si un método se llama estáticamente, la $thisvariable no está definida . Esto se debe a que no hay una instancia asociada con una llamada estática.
Lo interesante aquí es cómo se hacen las llamadas estáticas. Entonces, hablemos sobre cómo accedemos al estado:
Estado de acceso
Entonces, ahora que hemos almacenado ese estado, necesitamos acceder a él. Esto puede ser un poco complicado (o mucho más que un poco), así que dividámoslo en dos puntos de vista: desde fuera de una instancia / clase (por ejemplo, desde una llamada de función normal, o desde el alcance global), y dentro de una instancia / class (desde un método en el objeto).
Desde fuera de una instancia / clase
Desde el exterior de una instancia / clase, nuestras reglas son bastante simples y predecibles. Tenemos dos operadores, y cada uno nos dice de inmediato si estamos tratando con una instancia o una clase estática:
->- object-operator : esto siempre se usa cuando accedemos a una instancia.
$bob = new Person;
echo $bob->name;
Es importante tener en cuenta que llamar Person->foono tiene sentido (ya que Persones una clase, no una instancia). Por lo tanto, eso es un error de análisis.
::- scope-resolution-operator : siempre se usa para acceder a una propiedad o método estático de la Clase.
echo Foo::bar()
Además, podemos llamar a un método estático en un objeto de la misma manera:
echo $foo::bar()
Es extremadamente importante tener en cuenta que cuando hacemos esto desde afuera , la instancia del objeto está oculta del bar()método. Lo que significa que es exactamente lo mismo que correr:
$class = get_class($foo);
$class::bar();
Por lo tanto, $thisno está definido en la llamada estática.
Desde el interior de una instancia / clase
Las cosas cambian un poco aquí. Se utilizan los mismos operadores, pero su significado se vuelve significativamente borroso.
El operador de objeto -> todavía se utiliza para realizar llamadas al estado de instancia del objeto.
class Foo {
public $a = 1;
public function bar() {
return $this->a;
}
}
Llamar al bar()método en $foo(una instancia de Foo) utilizando el operador de objeto: $foo->bar()dará como resultado la versión de la instancia de $a.
Así es como esperamos.
::Aunque el significado del operador cambia. Depende del contexto de la llamada a la función actual:
Dentro de un contexto estático
Dentro de un contexto estático, cualquier llamada realizada con ::también será estática. Veamos un ejemplo:
class Foo {
public function bar() {
return Foo::baz();
}
public function baz() {
return isset($this);
}
}
La llamada Foo::bar()llamará al baz()método de forma estática y, por $thislo tanto , no se completará. Vale la pena señalar que en versiones recientes de PHP (5.3+) esto provocará un E_STRICTerror, porque estamos llamando a métodos no estáticos estáticamente.
Dentro de un contexto de instancia
Por otro lado, dentro de un contexto de instancia, las llamadas realizadas ::dependen del receptor de la llamada (el método al que estamos llamando). Si el método se define como static, utilizará una llamada estática. Si no es así, reenviará la información de la instancia.
Entonces, mirando el código anterior, la llamada $foo->bar()volverá true, ya que la llamada "estática" ocurre dentro de un contexto de instancia.
¿Tener sentido? No lo creo. Es confuso.
Palabras clave de atajo
Debido a que unir todo usando nombres de clase es bastante sucio, PHP proporciona 3 palabras clave básicas de "acceso directo" para facilitar la resolución del alcance.
self- Esto se refiere al nombre de la clase actual. Entonces self::baz()es lo mismo que Foo::baz()dentro de la Fooclase (cualquier método en él).
parent - Esto se refiere al padre de la clase actual.
static- Esto se refiere a la clase llamada. Gracias a la herencia, las clases secundarias pueden anular métodos y propiedades estáticas. Entonces, llamarlos usando en staticlugar de un nombre de clase nos permite resolver de dónde vino la llamada, en lugar del nivel actual.
Ejemplos
La forma más fácil de entender esto es comenzar a mirar algunos ejemplos. Vamos a elegir una clase:
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();
}
}
Ahora, también estamos viendo herencia aquí. Ignora por un momento que este es un modelo de objeto malo, pero veamos qué sucede cuando jugamos con esto:
$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
Por lo tanto, el contador de ID se comparte entre las instancias y los elementos secundarios (porque lo estamos utilizando selfpara acceder a él. Si lo utilizáramos static, podríamos anularlo en una clase secundaria).
var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy
Tenga en cuenta que estamos ejecutando el método de Person::getName() instancia cada vez. Pero estamos usando el parent::getName()para hacerlo en uno de los casos (el caso secundario). Esto es lo que hace que este enfoque sea poderoso.
Palabra de precaución # 1
Tenga en cuenta que el contexto de llamada es lo que determina si se utiliza una instancia. Por lo tanto:
class Foo {
public function isFoo() {
return $this instanceof Foo;
}
}
No siempre es verdad.
class Bar {
public function doSomething() {
return Foo::isFoo();
}
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)
Ahora es realmente raro aquí. Estamos llamando a una clase diferente, pero la $thisque se pasa al Foo::isFoo()método es la instancia de $bar.
Esto puede causar todo tipo de errores y errores conceptuales de WTF. Así que yo recomiendo evitando el ::operador desde el interior de los métodos de instancia en cualquier cosa excepto aquellas tres palabras clave virtuales "atajo" ( static, selfy parent).
Palabra de precaución # 2
Tenga en cuenta que los métodos y propiedades estáticos son compartidos por todos. Eso los convierte básicamente en variables globales. Con los mismos problemas que vienen con los globales. Por lo tanto, dudaría mucho en almacenar información en métodos / propiedades estáticas a menos que se sienta cómodo con que sea realmente global.
Palabra de precaución # 3
En general, querrá usar lo que se conoce como enlace estático tardío utilizando en staticlugar de self. Pero tenga en cuenta que no son lo mismo, por lo que decir "siempre usar en staticlugar de selfes realmente miope. En cambio, deténgase y piense en la llamada que desea hacer y piense si desea que las clases secundarias puedan anular esa estática resuelta llamada.
TL / DR
Lástima, vuelve y léelo. Puede ser demasiado largo, pero es tan largo porque este es un tema complejo
TL / DR # 2
Está bien. En resumen, selfse utiliza para hacer referencia al nombre de la clase actual dentro de una clase, donde se $thisrefiere a la instancia del objeto actual . Tenga en cuenta que selfes un atajo de copiar / pegar. Puede reemplazarlo con seguridad con el nombre de su clase, y funcionará bien. Pero $thises una variable dinámica que no se puede determinar con anticipación (y puede que ni siquiera sea su clase).
TL / DR # 3
Si se usa el operador de objeto ( ->), siempre sabrá que está tratando con una instancia. Si se utiliza el operador de resolución de alcance ( ::), necesita más información sobre el contexto (¿ya estamos en un contexto de objeto? ¿Estamos fuera de un objeto? Etc.).