Per capire veramente di cosa stiamo parlando quando parliamo di selfcontro $this, dobbiamo davvero scavare in quello che sta succedendo a livello concettuale e pratico. Non credo che nessuna delle risposte lo faccia in modo appropriato, quindi ecco il mio tentativo.
Cominciamo parlando di cosa sono una classe e un oggetto .
Classi e oggetti, concettualmente
Allora, che cosa è un codice categoria ? Molte persone lo definiscono come un progetto o un modello per un oggetto. In effetti, puoi leggere di più sulle classi in PHP qui . E fino a un certo punto è così. Diamo un'occhiata a una classe:
class Person {
public $name = 'my name';
public function sayHello() {
echo "Hello";
}
}
Come puoi vedere, esiste una proprietà su quella classe chiamata $namee un metodo (funzione) chiamato sayHello().
È molto importante notare che la classe è una struttura statica. Ciò significa che la classe Person, una volta definita, è sempre la stessa ovunque la guardi.
Un oggetto d'altra parte è ciò che viene chiamato un'istanza di una classe. Ciò significa che prendiamo il "progetto" della classe e lo usiamo per fare una copia dinamica. Questa copia ora è specificamente legata alla variabile in cui è archiviata. Pertanto, qualsiasi modifica a un'istanza è locale a tale istanza.
$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"
Creiamo nuove istanze di una classe utilizzando l' newoperatore.
Pertanto, diciamo che una classe è una struttura globale e un oggetto è una struttura locale. Non preoccuparti di quella ->sintassi divertente , ci entreremo tra poco.
Un'altra cosa di cui dovremmo parlare è che possiamo verificare se un'istanza è una instanceofclasse particolare: $bob instanceof Personche restituisce un valore booleano se l' $bobistanza è stata creata usando la Personclasse, o un figlio di Person.
Definire lo stato
Quindi scaviamo un po 'in ciò che effettivamente contiene una classe. Esistono 5 tipi di "cose" che una classe contiene:
Proprietà : pensa a queste come variabili che ogni istanza conterrà.
class Foo {
public $bar = 1;
}
Proprietà statiche - Pensa a queste come variabili condivise a livello di classe. Ciò significa che non vengono mai copiati da ciascuna istanza.
class Foo {
public static $bar = 1;
}
Metodi : sono funzioni che ogni istanza conterrà (e opererà su istanze).
class Foo {
public function bar() {}
}
Metodi statici : si tratta di funzioni condivise nell'intera classe. Essi non operano su istanze, ma invece sul solo le proprietà statiche.
class Foo {
public static function bar() {}
}
Costanti : costanti risolte in classe. Non andare più in profondità qui, ma aggiungendo per completezza:
class Foo {
const BAR = 1;
}
Quindi, in sostanza, stiamo memorizzando informazioni sulla classe e sul contenitore oggetti usando "suggerimenti" su static che identificano se le informazioni sono condivise (e quindi statiche) o meno (e quindi dinamiche).
Stato e metodi
All'interno di un metodo, l'istanza di un oggetto è rappresentata dalla $thisvariabile. Lo stato corrente di quell'oggetto è presente e la mutazione (modifica) di qualsiasi proprietà comporterà una modifica a quell'istanza (ma non ad altre).
Se un metodo viene chiamato staticamente, la $thisvariabile non è definita . Questo perché non esiste un'istanza associata a una chiamata statica.
La cosa interessante qui è come vengono fatte le chiamate statiche. Quindi parliamo di come accediamo allo stato:
Stato di accesso
Quindi ora che abbiamo memorizzato quello stato, dobbiamo accedervi. Questo può diventare un po 'complicato (o molto più di un po'), quindi dividiamolo in due punti di vista: dall'esterno di un'istanza / classe (diciamo da una normale chiamata di funzione o dall'ambito globale) e all'interno di un'istanza / class (dall'interno di un metodo sull'oggetto).
Dall'esterno di un'istanza / classe
Dall'esterno di un'istanza / classe, le nostre regole sono abbastanza semplici e prevedibili. Abbiamo due operatori e ognuno ci dice immediatamente se abbiamo a che fare con un'istanza o una classe statica:
->- object-operator : viene sempre utilizzato quando si accede a un'istanza.
$bob = new Person;
echo $bob->name;
È importante notare che la chiamata Person->foonon ha senso (poiché Personè una classe, non un'istanza). Pertanto, questo è un errore di analisi.
:: - scope-risoluzione-operatore : viene sempre utilizzato per accedere a una proprietà o un metodo statici di classe.
echo Foo::bar()
Inoltre, possiamo chiamare un metodo statico su un oggetto allo stesso modo:
echo $foo::bar()
È estremamente importante notare che quando lo facciamo dall'esterno , l'istanza dell'oggetto è nascosta dal bar()metodo. Ciò significa che è esattamente lo stesso della corsa:
$class = get_class($foo);
$class::bar();
Pertanto, $thisnon è definito nella chiamata statica.
Dall'interno di un'istanza / classe
Le cose cambiano un po 'qui. Vengono utilizzati gli stessi operatori, ma il loro significato diventa significativamente sfocato.
L' operatore oggetto -> viene ancora utilizzato per effettuare chiamate allo stato dell'istanza dell'oggetto.
class Foo {
public $a = 1;
public function bar() {
return $this->a;
}
}
Richiamare il bar()metodo su $foo(un'istanza di Foo) utilizzando l'operatore oggetto: $foo->bar()comporterà la versione dell'istanza di$a .
Quindi è così che ci aspettiamo.
Il significato ::dell'operatore però cambia. Dipende dal contesto della chiamata alla funzione corrente:
In un contesto statico
In un contesto statico, anche tutte le chiamate effettuate utilizzando ::saranno statiche. Diamo un'occhiata a un esempio:
class Foo {
public function bar() {
return Foo::baz();
}
public function baz() {
return isset($this);
}
}
Chiamando Foo::bar()chiamerà il baz()metodo statico, e quindi $thissarà non essere popolato. Vale la pena notare che nelle ultime versioni di PHP (5.3+) questo causerà un E_STRICTerrore, perché stiamo chiamando staticamente metodi non statici.
In un contesto di istanza
D'altro canto, all'interno di un contesto di istanza, le chiamate effettuate tramite ::dipendono dal destinatario della chiamata (il metodo che stiamo chiamando). Se il metodo è definito comestatic , utilizzerà una chiamata statica. In caso contrario, inoltrerà le informazioni sull'istanza.
Quindi, guardando il codice sopra, la chiamata $foo->bar()tornerà true, poiché la chiamata "statica" avviene all'interno di un contesto di istanza.
Ha senso? Non la pensavo così. È confusionario.
Parole chiave di scelta rapida
Poiché legare tutto insieme usando i nomi delle classi è piuttosto sporco, PHP fornisce 3 parole chiave di base "scorciatoia" per facilitare la risoluzione dell'ambito.
self- Questo si riferisce al nome della classe corrente. Quindi self::baz()è lo stesso Foo::baz()della Fooclasse (qualsiasi metodo su di essa).
parent - Questo si riferisce al genitore della classe corrente.
static- Questo si riferisce alla classe chiamata. Grazie all'ereditarietà, le classi figlio possono sovrascrivere metodi e proprietà statiche. Quindi chiamarli usando staticinvece di un nome di classe ci consente di risolvere da dove proviene la chiamata, piuttosto che il livello corrente.
Esempi
Il modo più semplice per capirlo è iniziare a guardare alcuni esempi. Scegliamo un corso:
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();
}
}
Ora, stiamo anche guardando l'eredità qui. Ignora per un momento che questo è un cattivo modello a oggetti, ma diamo un'occhiata a cosa succede quando giochiamo con questo:
$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
Quindi il contatore ID è condiviso da entrambe le istanze e dai figli (perché stiamo usando selfper accedervi. Se lo usassimo static, potremmo sovrascriverlo in una classe figlio).
var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy
Nota che stiamo eseguendo il metodo di Person::getName() istanza ogni volta. Ma stiamo usando ilparent::getName() per farlo in uno dei casi (il caso figlio). Questo è ciò che rende potente questo approccio.
Parola di cautela n. 1
Si noti che il contesto chiamante è ciò che determina se viene utilizzata un'istanza. Perciò:
class Foo {
public function isFoo() {
return $this instanceof Foo;
}
}
Non è sempre vero.
class Bar {
public function doSomething() {
return Foo::isFoo();
}
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)
Ora è davvero strano qui. Stiamo chiamando una classe diversa, ma quella $thische viene passata al Foo::isFoo()metodo è l'istanza di$bar .
Ciò può causare tutti i tipi di bug e concetti WTF concettuali. Così mi piacerebbe consiglio vivamente di evitare l' ::operatore all'interno di metodi di istanza su nulla, tranne quelle tre virtuali "scorciatoia" parole chiave ( static, self, eparent ).
Parola di attenzione # 2
Si noti che i metodi e le proprietà statici sono condivisi da tutti. Ciò li rende sostanzialmente variabili globali. Con tutti gli stessi problemi che derivano dai globali. Quindi esiterei davvero a conservare le informazioni in metodi / proprietà statici a meno che non ti senta a tuo agio nel fatto che siano veramente globali.
Parola di cautela n. 3
In generale, ti consigliamo di utilizzare il cosiddetto Late-Static-Binding utilizzando staticanziché self. Ma nota che non sono la stessa cosa, quindi dire "usa sempre staticinvece di selfè davvero miope. Invece, fermati e pensa alla chiamata che vuoi fare e pensa se vuoi che le classi secondarie siano in grado di scavalcare quella statica risolta chiamata.
TL / DR
Peccato, torna indietro e leggilo. Potrebbe essere troppo lungo, ma è così lungo perché questo è un argomento complesso
TL / DR # 2
Ok bene. In breve, selfviene utilizzato per fare riferimento al nome della classe corrente all'interno di una classe, dove come si $thisriferisce all'istanza dell'oggetto corrente . Si noti che selfè una scorciatoia copia / incolla. Puoi tranquillamente sostituirlo con il nome della tua classe e funzionerà benissimo. Ma$this è una variabile dinamica che non può essere determinata in anticipo (e potrebbe anche non essere la tua classe).
TL / DR # 3
Se viene utilizzato l'operatore oggetto ( ->), allora sai sempre che hai a che fare con un'istanza. Se viene utilizzato l'operatore di risoluzione dell'ambito ( ::), sono necessarie ulteriori informazioni sul contesto (siamo già in un contesto di oggetto? Siamo al di fuori di un oggetto? Ecc.).