Lorsque la partie gauche est une instance d'objet, vous utilisez ->
. Sinon, vous utilisez ::
.
Cela signifie qu'il ->
est principalement utilisé pour accéder aux membres d'instance (bien qu'il puisse également être utilisé pour accéder aux membres statiques, une telle utilisation est déconseillée), tandis qu'il ::
est généralement utilisé pour accéder aux membres statiques (bien que dans quelques cas spéciaux, il soit utilisé pour accéder aux membres d'instance ).
En général, ::
est utilisé pour la résolution de portée , et il peut avoir soit un nom de classe, parent
, self
ou (en PHP 5.3) static
à sa gauche. parent
fait référence à la portée de la superclasse de la classe où elle est utilisée; self
fait référence à la portée de la classe où elle est utilisée; static
fait référence à la "portée appelée" (voir les liaisons statiques tardives ).
La règle est qu'un appel avec ::
est un appel d'instance si et seulement si:
- la méthode cible n'est pas déclarée comme statique et
- il existe un contexte d'objet compatible au moment de l'appel, ce qui signifie qu'il doit être vrai:
- l'appel est fait à partir d'un contexte où
$this
existe et
- la classe de
$this
est soit la classe de la méthode appelée, soit une sous-classe de celle-ci.
Exemple:
class A {
public function func_instance() {
echo "in ", __METHOD__, "\n";
}
public function callDynamic() {
echo "in ", __METHOD__, "\n";
B::dyn();
}
}
class B extends A {
public static $prop_static = 'B::$prop_static value';
public $prop_instance = 'B::$prop_instance value';
public function func_instance() {
echo "in ", __METHOD__, "\n";
/* this is one exception where :: is required to access an
* instance member.
* The super implementation of func_instance is being
* accessed here */
parent::func_instance();
A::func_instance(); //same as the statement above
}
public static function func_static() {
echo "in ", __METHOD__, "\n";
}
public function __call($name, $arguments) {
echo "in dynamic $name (__call)", "\n";
}
public static function __callStatic($name, $arguments) {
echo "in dynamic $name (__callStatic)", "\n";
}
}
echo 'B::$prop_static: ', B::$prop_static, "\n";
echo 'B::func_static(): ', B::func_static(), "\n";
$a = new A;
$b = new B;
echo '$b->prop_instance: ', $b->prop_instance, "\n";
//not recommended (static method called as instance method):
echo '$b->func_static(): ', $b->func_static(), "\n";
echo '$b->func_instance():', "\n", $b->func_instance(), "\n";
/* This is more tricky
* in the first case, a static call is made because $this is an
* instance of A, so B::dyn() is a method of an incompatible class
*/
echo '$a->dyn():', "\n", $a->callDynamic(), "\n";
/* in this case, an instance call is made because $this is an
* instance of B (despite the fact we are in a method of A), so
* B::dyn() is a method of a compatible class (namely, it's the
* same class as the object's)
*/
echo '$b->dyn():', "\n", $b->callDynamic(), "\n";
Production:
B :: $ prop_static: B :: $ prop_static valeur
B :: func_static (): dans B :: func_static
$ b-> prop_instance: B :: $ prop_instance valeur
$ b-> func_static (): dans B :: func_static
$ b-> func_instance ():
dans B :: func_instance
dans A :: func_instance
dans A :: func_instance
$ a-> dyn ():
dans A :: callDynamic
en dynamique dyn (__callStatic)
$ b-> dyn ():
dans A :: callDynamic
en dynamique dyn (__call)